React Academy · Lektion

Generiske komponenter og utility-typer

Skriv genanvendelige generiske komponenter, og brug PropsWithChildren, ComponentProps og Omit.

Lektion 3 af 413 trin

Generiske komponenter og utility-typer er en gratis React Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i React Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. React Academy-kurset indeholder 4 lektioner i alt.

Hvorfor generiske komponenter?

Generiske komponenter tilpasser sig forskellige datatyper og forbliver samtidig fuldt typesikre — en typet liste, vælger eller tabel, der fungerer med enhver datastruktur.

En simpel generisk liste

Brug en typeparameter T på funktionen for at lave en listekomponent, der gengiver elementer af enhver type.

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>
  );
}

Begrænsning af generiske typer

Brug extends til at tilføje begrænsninger, så TypeScript ved, hvilke egenskaber typen skal have.

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> tilføjer children?: React.ReactNode til enhver prop-type — nyttigt til wrapper-komponenter.

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

ComponentProps

React.ComponentProps<typeof Component> udleder props fra en eksisterende komponent, hvilket er nyttigt, når du vil udvide eller pakke den ind.

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'> udleder HTML-elementets props uden ref-proppen — ideelt til indpakning af HTML-elementer.

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 og Pick

Brug Omit<T, Keys> til at fjerne bestemte props og Pick<T, Keys> til kun at beholde bestemte props fra en eksisterende type.

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 og Required

Partial<T> gør alle props valgfrie, hvilket er nyttigt til opdateringsformularer. Required<T> gør alle props påkrævede.

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 til typede ordbøger

Record<Keys, Value> opretter en objekttype med bestemte nøgletype, hvilket er nyttigt til opslagstabeller og oversættelser.

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

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

ReturnType til hook-typer

Brug ReturnType<typeof useMyHook> til at udlede returtypen for en brugerdefineret hook uden manuelt at kopiere typen.

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 }

Generisk tabelkomponent

En fuldt typesikker datatabel, der fungerer med enhver rækkestruktur, udleder kolonnenøgler og stadig giver autoudførelse.

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>
  );
}

Hurtigt tjek

Hvilken hjælpe-type fjerner angivne nøgler fra en eksisterende TypeScript-grænseflade?

Besvar den i den interaktive lektion

Opsummering

Generiske komponenter bruger typeparametre til at forblive typesikre på tværs af forskellige datastrukturer. Hjælpe-typer som Omit, Pick, Partial, ComponentProps og PropsWithChildren fjerner behovet for manuel gentagelse af typer og gør komponent-API'er mere sammensættelige.

Gratis at komme i gang

Lær React med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 88
Lektioner: 324

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Generiske komponenter og utility-typer” gratis?

Ja — hele teksten til “Generiske komponenter og utility-typer” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af React Academy-kurset, skal du opgradere til CoddyKit PRO. React Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Generiske komponenter og utility-typer”?

Skriv genanvendelige generiske komponenter, og brug PropsWithChildren, ComponentProps og Omit. Du øver dig i React Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på React Academy?

Der kræves ingen tidligere erfaring. React Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Generiske komponenter og utility-typer”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne React Academy-lektion?

Ja. Alle React Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Typning af props og komponenters returtyper
Typning af events og refs i TypeScript
Generiske komponenter og utility-typer
Typning af kontekst og custom hooks

← Tilbage til React Academy