Richtlinien für die Frontend-Entwicklung
Zweck
Umfassender Leitfaden für die moderne Entwicklung mit Next.js 15 und React 19 mit Fokus auf Server Components, Client Components, App Router-Muster, Shadcn/ui-Komponenten, richtige Dateiorganisation und Leistungsoptimierung.
Wann dieses Skill verwendet werden sollte
- Erstellen neuer Komponenten oder Seiten
- Entwickeln neuer Funktionen
- Abrufen von Daten (Server Components, Server Actions)
- Einrichten des Routings mit dem Next.js App Router
- Stylen von Komponenten mit Tailwind CSS und Shadcn/ui
- Leistungsoptimierung
- Organisieren von Frontend-Code
- TypeScript-Best-Practices
Schnellstart
Checkliste für neue Komponenten
Beim Erstellen einer Komponente dieser Checkliste folgen:
- Entscheiden zwischen Server- und Client-Komponente (Standard: Server-Komponente)
-
"use client"-Direktive nur bei Bedarf hinzufügen (Interaktivität, Hooks, Browser-APIs) - TypeScript mit expliziten Prop-Typen verwenden
- Shadcn/ui-Komponenten aus
@/components/uiimportieren - Tailwind CSS-Klassen zum Stylen verwenden
- Import-Aliase verwenden:
@/components,@/lib,@/hooks -
cn()-Utility für bedingte Klassen verwenden - Standard-Export am Ende
- Nach Möglichkeit Server-Komponenten für den Datenabruf verwenden
Checkliste für neue Seiten
Beim Erstellen einer Seite diese Struktur einrichten:
-
app/{route-name}/page.tsxfür die Route erstellen - Standardmäßig Server-Komponente verwenden
- Daten direkt in der Server-Komponente abrufen
-
components/-Verzeichnis für seiten-spezifische Komponenten erstellen -
loading.tsxfür Ladezustände verwenden -
error.tsxfür Fehlergrenzen verwenden - Metadaten für SEO exportieren
Import-Aliase Kurzreferenz
| Alias | Löst auf | Beispiel |
|---|---|---|
@/ | Projektstamm | import { cn } from '@/lib/utils' |
@/components | components/ | import { Button } from '@/components/ui/button' |
@/lib | lib/ | import { cn } from '@/lib/utils' |
@/hooks | hooks/ | import { useMobile } from '@/hooks/use-mobile' |
@/app | app/ | import { Metadata } from 'next' |
Definiert in: tsconfig.json-Pfadkonfiguration
Spickzettel für häufige Importe
// Next.js
import { Metadata } from 'next'
import { Suspense } from 'react'
import { notFound, redirect } from 'next/navigation'
// React (nur Client-Komponenten)
;("use client")
import { useState, useCallback, useMemo } from 'react'
// Shadcn/ui-Komponenten
import { Button } from '@/components/ui/button'
import { Card, CardHeader, CardTitle, CardContent } from '@/components/ui/card'
import { Input } from '@/components/ui/input'
// Werkzeuge
import { cn } from '@/lib/utils'
// Hooks (nur Client-Komponenten)
import { useMobile } from '@/hooks/use-mobile'
// Typen
import type { ComponentProps } from 'react'
Themenführungen
🎨 Komponentenmuster
Server-Komponenten vs. Client-Komponenten:
- Server-Komponenten (Standard): Kein
"use client", können Daten direkt abrufen, kleineres Bundle - Client-Komponenten: Fügen Sie
"use client"für Interaktivität, Hooks, Browser-APIs hinzu
Schlüsselkonzepte:
- Standardmäßig Server-Komponenten verwenden
- Client-Komponenten nur bei Bedarf einsetzen
- Shadcn/ui-Komponenten nutzen (bereits Client-Komponenten)
- Komponentenstruktur: Props → Datenabruf → Rendern → Export
Beispiel einer Server-Komponente:
// app/features/posts/components/PostList.tsx
import { Card, CardHeader, CardTitle, CardContent } from '@/components/ui/card'
interface PostListProps {
posts: Post[]
}
export function PostList({ posts }: PostListProps) {
return (
<div className='grid gap-4'>
{posts.map((post) => (
<Card key={post.id}>
<CardHeader>
<CardTitle>{post.title}</CardTitle>
</CardHeader>
<CardContent>{post.content}</CardContent>
</Card>
))}
</div>
)
}
Beispiel einer Client-Komponente:
// app/features/posts/components/PostForm.tsx
'use client'
import { useState } from 'react'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
export function PostForm() {
const [title, setTitle] = useState('')
return (
<form>
<Input value={title} onChange={(e) => setTitle(e.target.value)} />
<Button type='submit'>Absenden</Button>
</form>
)
}
📊 Datenabruf
PRIMÄRES MUSTER: Server-Komponenten
- Daten direkt in Server-Komponenten abrufen
async/awaitin Server-Komponenten verwenden- Kein Bedarf an
useEffectoder Datenabruf-Bibliotheken - Automatische Anforderungsdeduplizierung
Server-Aktionen:
- Für Mutationen (Formulare, Aktualisierungen) verwenden
app/actions/-Verzeichnis erstellen- Mit
"use server"-Direktive markieren
Beispiel einer Server-Komponente mit Datenabruf:
// app/posts/page.tsx
import { PostList } from '@/components/PostList'
async function getPosts() {
const res = await fetch('https://api.example.com/posts', {
cache: 'no-store', // oder 'force-cache', 'revalidate'
})
return res.json()
}
export default async function PostsPage() {
const posts = await getPosts()
return <PostList posts={posts} />
}
Beispiel einer Server-Aktion:
// app/actions/posts.ts
'use server'
export async function createPost(formData: FormData) {
const title = formData.get('title')
// ... Validierungs- und Erstellungslogik
redirect('/posts')
}
📁 Dateiorganisation
App Router-Struktur:
app/
(routes)/
page.tsx # Routenseite
layout.tsx # Routenlayout
loading.tsx # Lade-UI
error.tsx # Fehler-UI
components/ # Gemeinsame Komponenten
ui/ # Shadcn/ui-Komponenten
features/ # Funktionsspezifischer Code
posts/
components/ # Funktionskomponenten
actions/ # Server-Aktionen
types/ # TypeScript-Typen
lib/
utils.ts # Werkzeuge (cn, usw.)
hooks/
use-mobile.ts # Benutzerdefinierte Hooks (nur Client)
Funktionsorganisation:
app/features/{feature}/: Funktionsspezifische Seiten/Routencomponents/: Wiederverwendbare Komponentencomponents/ui/: Shadcn/ui-Komponenten (nicht direkt ändern)
🎨 Styling
Tailwind CSS + Shadcn/ui:
- Tailwind-Utility-Klassen verwenden
cn()-Utility für bedingte Klassen verwenden- Shadcn/ui-Komponenten verwenden CSS-Variablen für das Theming
- Theme in
app/globals.cssanpassen
Styling-Muster:
import { cn } from '@/lib/utils'
interface ButtonProps {
variant?: 'primary' | 'secondary'
className?: string
}
export function Button({ variant = 'primary', className }: ButtonProps) {
return (
<button
className={cn(
'rounded-md px-4 py-2',
variant === 'primary' && 'bg-primary text-primary-foreground',
variant === 'secondary' && 'bg-secondary text-secondary-foreground',
className,
)}
>
Klick mich
</button>
)
}
Shadcn/ui-Komponenten:
- Aus
@/components/ui/{component-name}importieren - Komponenten sind bereits gestylt und barrierefrei
- Anpassung über
className-Prop oder CSS-Variablen
🛣️ Routing
Next.js App Router - Dateibasiert:
- Verzeichnis:
app/{route-name}/page.tsx - Verschachtelte Routen:
app/{parent}/{child}/page.tsx - Dynamische Routen:
app/posts/[id]/page.tsx - Routengruppen:
app/(marketing)/about/page.tsx
Beispiel einer Route:
// app/posts/page.tsx
import { Metadata } from 'next'
import { PostList } from '@/components/PostList'
export const metadata: Metadata = {
title: 'Beiträge',
description: 'Liste aller Beiträge',
}
export default async function PostsPage() {
const posts = await getPosts()
return (
<div className='container mx-auto py-8'>
<h1 className='text-3xl font-bold mb-6'>Beiträge</h1>
<PostList posts={posts} />
</div>
)
}
Dynamische Route:
// app/posts/[id]/page.tsx
interface PostPageProps {
params: Promise<{ id: string }>
}
export default async function PostPage({ params }: PostPageProps) {
const { id } = await params
const post = await getPost(id)
if (!post) {
notFound()
}
return <PostDetail post={post} />
}
⏳ Lade- und Fehlerzustände
Ladezustände:
loading.tsxim Routenverzeichnis erstellen- Umhüllt die Seite automatisch mit Suspense
- Für routenweites Laden verwenden
Fehlergrenzen:
error.tsxim Routenverzeichnis erstellen- Fängt Fehler in der Route automatisch ab
- Kann den Fehlerzustand zurücksetzen
Beispiel einer Lade-UI:
// app/posts/loading.tsx
export default function Loading() {
return (
<div className='flex items-center justify-center min-h-screen'>
<div className='animate-spin rounded-full h-8 w-8 border-b-2 border-primary' />
</div>
)
}
Beispiel einer Fehler-UI:
// app/posts/error.tsx
'use client'
import { useEffect } from 'react'
import { Button } from '@/components/ui/button'
export default function Error({
error,
reset,
}: {
error: Error & { digest?: string }
reset: () => void
}) {
useEffect(() => {
console.error(error)
}, [error])
return (
<div className='flex flex-col items-center justify-center min-h-screen'>
<h2 className='text-2xl font-bold mb-4'>Etwas ist schiefgelaufen!</h2>
<Button onClick={reset}>Erneut versuchen</Button>
</div>
)
}
⚡ Leistung
Optimierungsmuster:
- Server-Komponenten verwenden (kleineres Bundle)
next/imagefür Bilder verwendennext/fontfür Schriftarten verwenden- Client-Komponenten nach Möglichkeit lazy laden
useMemounduseCallbackin Client-Komponenten verwenden- Daten mit Suspense-Grenzen streamen
Bildoptimierung:
import Image from 'next/image'
export function Avatar({ src, alt }: { src: string; alt: string }) {
return (
<Image
src={src}
alt={alt}
width={40}
height={40}
className='rounded-full'
/>
)
}
Streaming mit Suspense:
import { Suspense } from 'react'
import { PostList } from '@/components/PostList'
import { Loading } from '@/components/Loading'
export default function Page() {
return (
<div>
<Suspense fallback={<Loading />}>
<PostList />
</Suspense>
</div>
)
}
📘 TypeScript
Standards:
- Strenger Modus aktiviert
- Kein
any-Typ - Explizite Rückgabetypen bei Funktionen
- Typ-Importe:
import type { Post } from '@/types/post' - Komponenten-Prop-Schnittstellen mit JSDoc
Beispiel:
import type { ComponentProps } from 'react'
import { Button } from '@/components/ui/button'
/**
* Benutzerdefinierte Schaltflächenkomponente mit Ladezustand
*/
interface CustomButtonProps extends ComponentProps<typeof Button> {
isLoading?: boolean
}
export function CustomButton({
isLoading,
children,
...props
}: CustomButtonProps) {
return (
<Button disabled={isLoading} {...props}>
{isLoading ? 'Lädt...' : children}
</Button>
)
}
🔧 Häufige Muster
Formularverarbeitung:
- Server-Aktionen für Formulareinreichungen verwenden
react-hook-formmitzodfür Validierung (Client-Komponenten) verwenden- Shadcn/ui-Formularkomponenten verwenden
Beispiel eines Formulars mit Server-Aktion:
// app/actions/posts.ts
'use server'
import { z } from 'zod'
const createPostSchema = z.object({
title: z.string().min(1),
content: z.string().min(1),
})
export async function createPost(formData: FormData) {
const rawData = {
title: formData.get('title'),
content: formData.get('content'),
}
const validated = createPostSchema.parse(rawData)
// ... Beitragserstellungslogik
redirect('/posts')
}
Metadaten:
import { Metadata } from 'next'
export const metadata: Metadata = {
title: 'Beiträge',
description: 'Liste aller Beiträge',
openGraph: {
title: 'Beiträge',
description: 'Liste aller Beiträge',
},
}
Kernprinzipien
- Server-Komponenten zuerst: Standardmäßig Server-Komponenten verwenden, Client-Komponenten nur bei Bedarf einsetzen
- App Router-Struktur: Dateibasiertes Routing mit
app/-Verzeichnis verwenden - Shadcn/ui-Komponenten: Vorgefertigte barrierefreie Komponenten verwenden
- Tailwind CSS: Utility-first Styling mit
cn()-Hilfsfunktion - TypeScript Streng: Kein
any, explizite Typen - Leistung: Server-Komponenten verwenden, Bilder optimieren, bei Bedarf lazy laden
- Dateiorganisation: Funktionen in
app/features/, Gemeinsames incomponents/ - Import-Aliase:
@/-Präfix für saubere Importe verwenden
Kurzreferenz: Dateistruktur
app/
layout.tsx # Stamm-Layout
page.tsx # Startseite
globals.css # Globale Styles
(routes)/
posts/
page.tsx # Beitragslistenseite
[id]/
page.tsx # Beitragsdetailseite
loading.tsx # Lade-UI
error.tsx # Fehler-UI
features/
posts/
components/
PostList.tsx # Funktionskomponenten
actions/
posts.ts # Server-Aktionen
components/
ui/ # Shadcn/ui-Komponenten
button.tsx
card.tsx
lib/
utils.ts # Werkzeuge (cn, usw.)
hooks/
use-mobile.ts # Benutzerdefinierte Hooks
Moderne Komponentenvorlage (Schnellkopie)
Server-Komponente:
// app/components/PostCard.tsx
import { Card, CardHeader, CardTitle, CardContent } from '@/components/ui/card'
import type { Post } from '@/types/post'
interface PostCardProps {
post: Post
}
export function PostCard({ post }: PostCardProps) {
return (
<Card>
<CardHeader>
<CardTitle>{post.title}</CardTitle>
</CardHeader>
<CardContent>
<p>{post.content}</p>
</CardContent>
</Card>
)
}
Client-Komponente:
// app/components/PostForm.tsx
'use client'
import { useState } from 'react'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
export function PostForm() {
const [title, setTitle] = useState('')
return (
<form>
<div>
<Input value={title} onChange={(e) => setTitle(e.target.value)} />
</div>
<Button type='submit'>Absenden</Button>
</form>
)
}
Abschluss
Diese Richtlinien stellen sicher, dass der Frontend-Code konsistent, wartbar und leistungsstark ist. Wenn Sie diese Muster befolgen, erstellen Sie skalierbare Anwendungen mit modernen Next.js- und React-Praktiken gemäß den Branchenstandards.