Was macht UI-Komponenten-Muster?
Wann dieses Skill verwenden
- Erstellen von Komponentenbibliotheken: Wiederverwendbare UI-Komponenten entwickeln
- Implementieren von Designsystemen: Konsistente UI-Muster anwenden
- Komplexe UI: Komponenten mit mehreren Varianten (Button, Modal, Dropdown)
- Refactoring: Doppelten Code in Komponenten auslagern
Anleitung
Schritt 1: Props-API-Design
Entwerfe Props, die einfach zu verwenden und erweiterbar sind.
Prinzipien:
- Klare Namen
- Sinnvolle Standardwerte
- Typdefinitionen mit TypeScript
- Optionale Props mit optionalem Marker (?)
Beispiel (Button):
interface ButtonProps {
// Erforderlich
children: React.ReactNode;
// Optional (mit Standardwerten)
variant?: 'primary' | 'secondary' | 'outline' | 'ghost';
size?: 'sm' | 'md' | 'lg';
disabled?: boolean;
isLoading?: boolean;
// Event-Handler
onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
// HTML-Attributvererbung
type?: 'button' | 'submit' | 'reset';
className?: string;
}
function Button({
children,
variant = 'primary',
size = 'md',
disabled = false,
isLoading = false,
onClick,
type = 'button',
className = '',
...rest
}: ButtonProps) {
const baseClasses = 'btn';
const variantClasses = `btn-${variant}`;
const sizeClasses = `btn-${size}`;
const classes = `${baseClasses} ${variantClasses} ${sizeClasses} ${className}`;
return (
<button
type={type}
className={classes}
disabled={disabled || isLoading}
onClick={onClick}
{...rest}
>
{isLoading ? <Spinner /> : children}
</button>
);
}
// Anwendungsbeispiel
<Button variant="primary" size="lg" onClick={() => alert('Geklickt!')}>
Klick mich
</Button>
Schritt 2: Kompositionsmuster
Kombiniere kleine Komponenten, um komplexe UIs zu erstellen.
Beispiel (Card):
// Card-Komponente (Container)
interface CardProps {
children: React.ReactNode;
className?: string;
}
function Card({ children, className = '' }: CardProps) {
return <div className={`card ${className}`}>{children}</div>;
}
// Card.Header
function CardHeader({ children }: { children: React.ReactNode }) {
return <div className="card-header">{children}</div>;
}
// Card.Body
function CardBody({ children }: { children: React.ReactNode }) {
return <div className="card-body">{children}</div>;
}
// Card.Footer
function CardFooter({ children }: { children: React.ReactNode }) {
return <div className="card-footer">{children}</div>;
}
// Compound-Component-Muster
Card.Header = CardHeader;
Card.Body = CardBody;
Card.Footer = CardFooter;
export default Card;
// Verwendung
import Card from './Card';
function ProductCard() {
return (
<Card>
<Card.Header>
<h3>Produktname</h3>
</Card.Header>
<Card.Body>
<img src="..." alt="Produkt" />
<p>Produktbeschreibung hier...</p>
</Card.Body>
<Card.Footer>
<button>In den Warenkorb</button>
</Card.Footer>
</Card>
);
}
Schritt 3: Render Props / Children als Funktion
Ein Muster für flexible Anpassungen.
Beispiel (Dropdown):
interface DropdownProps<T> {
items: T[];
renderItem: (item: T, index: number) => React.ReactNode;
onSelect: (item: T) => void;
placeholder?: string;
}
function Dropdown<T>({ items, renderItem, onSelect, placeholder }: DropdownProps<T>) {
const [isOpen, setIsOpen] = useState(false);
const [selected, setSelected] = useState<T | null>(null);
const handleSelect = (item: T) => {
setSelected(item);
onSelect(item);
setIsOpen(false);
};
return (
<div className="dropdown">
<button onClick={() => setIsOpen(!isOpen)}>
{selected ? renderItem(selected, -1) : placeholder || 'Auswählen...'}
</button>
{isOpen && (
<ul className="dropdown-menu">
{items.map((item, index) => (
<li key={index} onClick={() => handleSelect(item)}>
{renderItem(item, index)}
</li>
))}
</ul>
)}
</div>
);
}
// Verwendung
interface User {
id: string;
name: string;
avatar: string;
}
function UserDropdown() {
const users: User[] = [...];
return (
<Dropdown
items={users}
placeholder="Benutzer auswählen"
renderItem={(user) => (
<div className="user-item">
<img src={user.avatar} alt={user.name} />
<span>{user.name}</span>
</div>
)}
onSelect={(user) => console.log('Ausgewählt:', user)}
/>
);
}
Schritt 4: Trennung der Logik mit benutzerdefinierten Hooks
Trenne UI von Geschäftslogik.
Beispiel (Modal):
// hooks/useModal.ts
function useModal(initialOpen = false) {
const [isOpen, setIsOpen] = useState(initialOpen);
const open = useCallback(() => setIsOpen(true), []);
const close = useCallback(() => setIsOpen(false), []);
const toggle = useCallback(() => setIsOpen(prev => !prev), []);
return { isOpen, open, close, toggle };
}
// components/Modal.tsx
interface ModalProps {
isOpen: boolean;
onClose: () => void;
title: string;
children: React.ReactNode;
}
function Modal({ isOpen, onClose, title, children }: ModalProps) {
if (!isOpen) return null;
return (
<div className="modal-overlay" onClick={onClose}>
<div className="modal-content" onClick={(e) => e.stopPropagation()}>
<div className="modal-header">
<h2>{title}</h2>
<button onClick={onClose} aria-label="Schließen">×</button>
</div>
<div className="modal-body">{children}</div>
</div>
</div>
);
}
// Verwendung
function App() {
const { isOpen, open, close } = useModal();
return (
<>
<button onClick={open}>Modal öffnen</button>
<Modal isOpen={isOpen} onClose={close} title="Mein Modal">
<p>Modal-Inhalt hier...</p>
</Modal>
</>
);
}
Schritt 5: Leistungsoptimierung
Verhindere unnötige Neurenderings.
React.memo:
// ❌ Schlecht: Child rendert bei jedem Parent-Rendern neu
function ExpensiveComponent({ data }) {
console.log('Rendere...');
return <div>{/* Komplexe UI */}</div>;
}
// ✅ Gut: Rendert nur neu, wenn sich Props ändern
const ExpensiveComponent = React.memo(({ data }) => {
console.log('Rendere...');
return <div>{/* Komplexe UI */}</div>;
});
useMemo & useCallback:
function ProductList({ products, category }: { products: Product[]; category: string }) {
// ✅ Gefilterte Ergebnisse merken
const filteredProducts = useMemo(() => {
return products.filter(p => p.category === category);
}, [products, category]);
// ✅ Callback merken
const handleAddToCart = useCallback((productId: string) => {
// In den Warenkorb legen
console.log('Hinzufügen:', productId);
}, []);
return (
<div>
{filteredProducts.map(product => (
<ProductCard
key={product.id}
product={product}
onAddToCart={handleAddToCart}
/>
))}
</div>
);
}
const ProductCard = React.memo(({ product, onAddToCart }) => {
return (
<div>
<h3>{product.name}</h3>
<button onClick={() => onAddToCart(product.id)}>In den Warenkorb</button>
</div>
);
});
Ausgabeformat
Komponenten-Dateistruktur
components/
├── Button/
│ ├── Button.tsx # Hauptkomponente
│ ├── Button.test.tsx # Tests
│ ├── Button.stories.tsx # Storybook
│ ├── Button.module.css # Stile
│ └── index.ts # Export
├── Card/
│ ├── Card.tsx
│ ├── CardHeader.tsx
│ ├── CardBody.tsx
│ ├── CardFooter.tsx
│ └── index.ts
└── Modal/
├── Modal.tsx
├── useModal.ts # Benutzerdefinierter Hook
└── index.ts
Komponenten-Vorlage
import React from 'react';
export interface ComponentProps {
// Props-Definition
children: React.ReactNode;
className?: string;
}
/**
* Komponentenbeschreibung
*
* @example
* ```tsx
* <Component>Hallo</Component>
* ```
*/
export const Component = React.forwardRef<HTMLDivElement, ComponentProps>(
({ children, className = '', ...rest }, ref) => {
return (
<div ref={ref} className={`component ${className}`} {...rest}>
{children}
</div>
);
}
);
Component.displayName = 'Component';
export default Component;
Einschränkungen
Erforderliche Regeln (MÜSSEN)
-
Single-Responsibility-Prinzip: Eine Komponente hat nur eine Rolle
- Button behandelt nur Buttons, Form behandelt nur Formulare
-
Props-Typ-Definition: TypeScript-Interface erforderlich
- Ermöglicht Auto-Vervollständigung
- Typsicherheit
-
Barrierefreiheit: aria-*, role, tabindex, etc.
Verbotene Regeln (DÜRFEN NICHT)
-
Übermäßiges Props-Drilling: Verboten bei 5+ Ebenen Tiefe
- Context oder Composition verwenden
-
Keine Geschäftslogik: API-Aufrufe und komplexe Berechnungen in UI-Komponenten verbieten
- In benutzerdefinierte Hooks auslagern
-
Inline-Objekte/Funktionen: Leistungsverschlechterung
// ❌ Schlechtes Beispiel <Component style={{ color: 'red' }} onClick={() => handleClick()} /> // ✅ Gutes Beispiel const style = { color: 'red' }; const handleClick = useCallback(() => {...}, []); <Component style={style} onClick={handleClick} />
Beispiele
Beispiel 1: Accordion (Compound Component)
import React, { createContext, useContext, useState } from 'react';
// Zustand mit Context teilen
const AccordionContext = createContext<{
activeIndex: number | null;
setActiveIndex: (index: number | null) => void;
} | null>(null);
function Accordion({ children }: { children: React.ReactNode }) {
const [activeIndex, setActiveIndex] = useState<number | null>(null);
return (
<AccordionContext.Provider value={{ activeIndex, setActiveIndex }}>
<div className="accordion">{children}</div>
</AccordionContext.Provider>
);
}
function AccordionItem({ index, title, children }: {
index: number;
title: string;
children: React.ReactNode;
}) {
const context = useContext(AccordionContext);
if (!context) throw new Error('AccordionItem muss innerhalb von Accordion verwendet werden');
const { activeIndex, setActiveIndex } = context;
const isActive = activeIndex === index;
return (
<div className="accordion-item">
<button
className="accordion-header"
onClick={() => setActiveIndex(isActive ? null : index)}
aria-expanded={isActive}
>
{title}
</button>
{isActive && <div className="accordion-body">{children}</div>}
</div>
);
}
Accordion.Item = AccordionItem;
export default Accordion;
// Verwendung
<Accordion>
<Accordion.Item index={0} title="Abschnitt 1">
Inhalt für Abschnitt 1
</Accordion.Item>
<Accordion.Item index={1} title="Abschnitt 2">
Inhalt für Abschnitt 2
</Accordion.Item>
</Accordion>
Beispiel 2: Polymorphe Komponente (as-Prop)
type PolymorphicComponentProps<C extends React.ElementType> = {
as?: C;
children: React.ReactNode;
} & React.ComponentPropsWithoutRef<C>;
function Text<C extends React.ElementType = 'span'>({
as,
children,
...rest
}: PolymorphicComponentProps<C>) {
const Component = as || 'span';
return <Component {...rest}>{children}</Component>;
}
// Verwendung
<Text>Standard-Span</Text>
<Text as="h1">Überschrift 1</Text>
<Text as="p" style={{ color: 'blue' }}>Absatz</Text>
<Text as={Link} href="/about">Link</Text>
Best Practices
- Komposition vor Props: Kinderkomponenten statt vieler Props nutzen
- Controlled vs Uncontrolled: Je nach Situation wählen
- Standard-Props: Sinnvolle Standardwerte bereitstellen
- Storybook: Komponentendokumentation und -entwicklung
Referenzen
- React Patterns
- Compound Components
- Radix UI - Barrierefreie Komponenten
- Chakra UI - Komponentenbibliothek
- shadcn/ui - Copy-Paste-Komponenten
Metadaten
Version
- Aktuelle Version: 1.0.0
- Zuletzt aktualisiert: 2025-01-01
- Kompatible Plattformen: Claude, ChatGPT, Gemini
Verwandte Skills
- web-accessibility: Barrierefreie Komponenten
- state-management: Komponenten-Statusverwaltung
Tags
#UI-components #React #design-patterns #composition #TypeScript #frontend