0Pricing
React Academy · Lektion

Generische Components und Utility Types

Schreiben Sie wiederverwendbare generische Components und verwenden Sie PropsWithChildren, ComponentProps und Omit.

Generische Components und Utility Types ist eine kostenlose React Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des React Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der React Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum generische Komponenten?

Generische Komponenten passen sich an verschiedene Datentypen an und bleiben dabei vollständig typsicher — etwa eine typisierte Liste, Auswahl oder Tabelle, die mit jeder Datenform funktioniert.

Eine einfache generische Liste

Verwenden Sie einen Typparameter T für die Funktion, um eine Listenkomponente zu erstellen, die Elemente beliebiger Typen rendert.

interface ListProps<T> {
  items: T[];
  renderItem: (item: T, index: number) => React.ReactNode;
  keyExtractor: (item: T) => string;
}

function List<T>({ items, renderItem, keyExtractor }: ListProps<T>) {
  return (
    <ul>
      {items.map((item, i) => (
        <li key={keyExtractor(item)}>{renderItem(item, i)}</li>
      ))}
    </ul>
  );
}

Generische Typen einschränken

Verwenden Sie extends, um Einschränkungen hinzuzufügen, damit TypeScript weiß, welche Eigenschaften der Typ besitzen muss.

interface SelectProps<T extends { id: string; label: string }> {
  options: T[];
  value: T | null;
  onChange: (option: T) => void;
}

function Select<T extends { id: string; label: string }>(
  { options, value, onChange }: SelectProps<T>
) {
  return (
    <select value={value?.id} onChange={e => onChange(options.find(o => o.id === e.target.value)!)}>
      {options.map(o => <option key={o.id} value={o.id}>{o.label}</option>)}
    </select>
  );
}

PropsWithChildren

React.PropsWithChildren<P> fügt jedem Props-Typ children?: React.ReactNode hinzu — nützlich für Wrapper-Komponenten.

function Card({ title, children }: React.PropsWithChildren<{ title: string }>) {
  return (
    <div className="card">
      <h2>{title}</h2>
      {children}
    </div>
  );
}

ComponentProps

React.ComponentProps<typeof Component> extrahiert die Props einer vorhandenen Komponente und ist nützlich, wenn Sie sie erweitern oder umschließen möchten.

import { Button } from './Button';

type ExtendedButtonProps = React.ComponentProps<typeof Button> & {
  loading?: boolean;
};

function LoadingButton({ loading, children, ...props }: ExtendedButtonProps) {
  return (
    <Button {...props} disabled={loading || props.disabled}>
      {loading ? <Spinner /> : children}
    </Button>
  );
}

ComponentPropsWithoutRef

React.ComponentPropsWithoutRef<'input'> extrahiert die Props eines HTML-Elements ohne die ref-Prop — ideal zum Umschließen von HTML-Elementen.

type InputProps = React.ComponentPropsWithoutRef<'input'> & {
  label: string;
  error?: string;
};

function FormInput({ label, error, ...inputProps }: InputProps) {
  return (
    <div>
      <label>{label}</label>
      <input {...inputProps} />
      {error && <span className="error">{error}</span>}
    </div>
  );
}

Omit & Pick

Verwenden Sie Omit<T, Keys>, um bestimmte Props zu entfernen, und Pick<T, Keys>, um aus einem vorhandenen Typ nur bestimmte Props zu übernehmen.

interface UserCardProps {
  id: string;
  name: string;
  email: string;
  avatar: string;
  role: string;
}

// Only expose non-sensitive fields:
type PublicUserCardProps = Omit<UserCardProps, 'email' | 'role'>;
// Or pick exactly what you need:
type AvatarProps = Pick<UserCardProps, 'name' | 'avatar'>;

Partial & Required

Partial<T> macht alle Props optional (nützlich für Aktualisierungsformulare). Required<T> macht alle Props erforderlich.

interface UserFormData { name: string; email: string; bio: string; }

// For update: only send changed fields
type UserUpdatePayload = Partial<UserFormData>;

// For create: all fields are mandatory
type UserCreatePayload = Required<UserFormData>;

Record für typisierte Dictionaries

Record<Keys, Value> erstellt einen Objekttyp mit bestimmten Schlüsseltypen und ist nützlich für Nachschlagetabellen und Übersetzungen.

type Status = 'idle' | 'loading' | 'success' | 'error';

const statusLabels: Record<Status, string> = {
  idle: 'Ready',
  loading: 'Loading...',
  success: 'Done!',
  error: 'Something went wrong',
};

ReturnType für Hook-Typen

Verwenden Sie ReturnType<typeof useMyHook>, um den Rückgabetyp eines benutzerdefinierten Hooks abzuleiten, ohne den Typ manuell zu duplizieren.

function useCounter(initial: number) {
  const [count, setCount] = useState(initial);
  return { count, increment: () => setCount(c => c + 1) };
}

type CounterHook = ReturnType<typeof useCounter>;
// { count: number; increment: () => void }

Generische Tabellenkomponente

Eine vollständig typsichere Datentabelle, die mit jeder Zeilenform funktioniert, Spaltenschlüssel ableitet und weiterhin Autovervollständigung bietet.

interface Column<T> {
  key: keyof T;
  header: string;
  render?: (value: T[keyof T], row: T) => React.ReactNode;
}

function DataTable<T extends object>({ data, columns }: { data: T[]; columns: Column<T>[] }) {
  return (
    <table>
      <thead><tr>{columns.map(c => <th key={String(c.key)}>{c.header}</th>)}</tr></thead>
      <tbody>{data.map((row, i) => (
        <tr key={i}>{columns.map(c => <td key={String(c.key)}>{c.render ? c.render(row[c.key], row) : String(row[c.key])}</td>)}</tr>
      ))}</tbody>
    </table>
  );
}

Kurztest

Welcher Utility-Typ entfernt angegebene Schlüssel aus einem vorhandenen TypeScript-Interface?

Zusammenfassung

Generische Komponenten verwenden Typparameter, um über verschiedene Datenformen hinweg typsicher zu bleiben. Utility-Typen wie Omit, Pick, Partial, ComponentProps und PropsWithChildren vermeiden manuelle Typduplizierung und machen Komponenten-APIs besser kombinierbar.

Häufig gestellte Fragen

Ist die Lektion „Generische Components und Utility Types“ kostenlos?

Ja — der vollständige Text von „Generische Components und Utility Types“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des React Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der React Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Generische Components und Utility Types“?

Schreiben Sie wiederverwendbare generische Components und verwenden Sie PropsWithChildren, ComponentProps und Omit. Du übst React Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um React Academy zu starten?

Keine Vorkenntnisse erforderlich. React Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Generische Components und Utility Types“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser React Academy-Lektion Code schreiben und ausführen?

Ja. Jede React Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Props und Rückgabetypen von Components typisieren
  2. Events und Refs in TypeScript typisieren
  3. Generische Components und Utility Types
  4. Context und Custom Hooks typisieren
← Zurück zu React Academy