Guide de Développement Frontend
Objectif
Guide complet pour le développement moderne avec Next.js 15 et React 19, en mettant l'accent sur les Server Components, les Client Components, les modèles App Router, les composants Shadcn/ui, l'organisation appropriée des fichiers et l'optimisation des performances.
Quand utiliser ce skill
- Création de nouveaux composants ou pages
- Développement de nouvelles fonctionnalités
- Récupération de données (Server Components, Server Actions)
- Configuration du routage avec Next.js App Router
- Stylisation des composants avec Tailwind CSS et Shadcn/ui
- Optimisation des performances
- Organisation du code frontend
- Bonnes pratiques TypeScript
Démarrage rapide
Liste de vérification pour un nouveau composant
Vous créez un composant ? Suivez cette checklist :
- Déterminer Server vs Client Component (par défaut : Server Component)
- Ajouter la directive
"use client"uniquement si nécessaire (interactivité, hooks, API navigateur) - Utiliser TypeScript avec des types de props explicites
- Importer les composants Shadcn/ui depuis
@/components/ui - Utiliser les classes Tailwind CSS pour le style
- Utiliser les alias d'import :
@/components,@/lib,@/hooks - Utiliser l'utilitaire
cn()pour les classes conditionnelles - Export par défaut en bas
- Utiliser les Server Components pour la récupération de données lorsque c'est possible
Liste de vérification pour une nouvelle page
Vous créez une page ? Configurez cette structure :
- Créer
app/{nom-de-route}/page.tsxpour la route - Utiliser un Server Component par défaut
- Récupérer les données directement dans le Server Component
- Créer un répertoire
components/pour les composants spécifiques à la page - Utiliser
loading.tsxpour les états de chargement - Utiliser
error.tsxpour les limites d'erreur - Exporter les métadonnées pour le SEO
Référence rapide des alias d'import
| Alias | Résout vers | Exemple |
|---|---|---|
@/ | Racine du projet | 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' |
Défini dans : configuration paths de tsconfig.json
Aide-mémoire des imports courants
// Next.js
import { Metadata } from 'next'
import { Suspense } from 'react'
import { notFound, redirect } from 'next/navigation'
// React (Client Components uniquement)
;('use client')
import { useState, useCallback, useMemo } from 'react'
// Composants Shadcn/ui
import { Button } from '@/components/ui/button'
import { Card, CardHeader, CardTitle, CardContent } from '@/components/ui/card'
import { Input } from '@/components/ui/input'
// Utilitaires
import { cn } from '@/lib/utils'
// Hooks (Client Components uniquement)
import { useMobile } from '@/hooks/use-mobile'
// Types
import type { ComponentProps } from 'react'
Guides thématiques
🎨 Modèles de composants
Server Components vs Client Components :
- Server Components (par défaut) : Pas de
"use client", peuvent récupérer les données directement, bundle plus petit - Client Components : Ajouter
"use client"pour l'interactivité, les hooks, les API navigateur
Concepts clés :
- Par défaut, utiliser les Server Components
- Utiliser les Client Components uniquement lorsque nécessaire
- Utiliser les composants Shadcn/ui (déjà des Client Components)
- Structure du composant : Props → Récupération de données → Rendu → Export
Exemple de Server Component :
// 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>
)
}
Exemple de Client Component :
// 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'>Soumettre</Button>
</form>
)
}
📊 Récupération de données
MODÈLE PRINCIPAL : Server Components
- Récupérer les données directement dans les Server Components
- Utiliser
async/awaitdans les Server Components - Pas besoin de
useEffectni de bibliothèques de récupération de données - Déduplication automatique des requêtes
Server Actions :
- Utiliser pour les mutations (formulaires, mises à jour)
- Créer un répertoire
app/actions/ - Marquer avec la directive
"use server"
Exemple de Server Component avec récupération de données :
// app/posts/page.tsx
import { PostList } from '@/components/PostList'
async function getPosts() {
const res = await fetch('https://api.example.com/posts', {
cache: 'no-store', // ou 'force-cache', 'revalidate'
})
return res.json()
}
export default async function PostsPage() {
const posts = await getPosts()
return <PostList posts={posts} />
}
Exemple de Server Action :
// app/actions/posts.ts
'use server'
export async function createPost(formData: FormData) {
const title = formData.get('title')
// ... logique de validation et de création
redirect('/posts')
}
📁 Organisation des fichiers
Structure App Router :
app/
(routes)/
page.tsx # Page de route
layout.tsx # Mise en page de route
loading.tsx # Interface de chargement
error.tsx # Interface d'erreur
components/ # Composants partagés
ui/ # Composants Shadcn/ui
features/ # Code spécifique aux fonctionnalités
posts/
components/ # Composants de la fonctionnalité
actions/ # Server Actions
types/ # Types TypeScript
lib/
utils.ts # Utilitaires (cn, etc.)
hooks/
use-mobile.ts # Hooks personnalisés (Client uniquement)
Organisation par fonctionnalité :
app/features/{fonctionnalité}/: Pages/routes spécifiques à une fonctionnalitécomponents/: Composants véritablement réutilisablescomponents/ui/: Composants Shadcn/ui (ne pas modifier directement)
🎨 Stylisation
Tailwind CSS + Shadcn/ui :
- Utiliser les classes utilitaires Tailwind
- Utiliser l'utilitaire
cn()pour les classes conditionnelles - Les composants Shadcn/ui utilisent des variables CSS pour le thème
- Personnaliser le thème dans
app/globals.css
Modèles de stylisation :
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,
)}
>
Cliquez-moi
</button>
)
}
Composants Shadcn/ui :
- Importer depuis
@/components/ui/{nom-du-composant} - Les composants sont déjà stylisés et accessibles
- Personnaliser via la prop
classNameou les variables CSS
🛣️ Routage
Next.js App Router - Basé sur les fichiers :
- Répertoire :
app/{nom-de-route}/page.tsx - Routes imbriquées :
app/{parent}/{enfant}/page.tsx - Routes dynamiques :
app/posts/[id]/page.tsx - Groupes de routes :
app/(marketing)/about/page.tsx
Exemple de route :
// app/posts/page.tsx
import { Metadata } from 'next'
import { PostList } from '@/components/PostList'
export const metadata: Metadata = {
title: 'Articles',
description: 'Liste de tous les articles',
}
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'>Articles</h1>
<PostList posts={posts} />
</div>
)
}
Route dynamique :
// 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} />
}
⏳ États de chargement et d'erreur
États de chargement :
- Créer
loading.tsxdans le répertoire de la route - Enveloppe automatiquement la page dans Suspense
- Utiliser pour le chargement au niveau de la route
Limites d'erreur :
- Créer
error.tsxdans le répertoire de la route - Attrape automatiquement les erreurs dans la route
- Peut réinitialiser l'état d'erreur
Exemple d'interface de chargement :
// 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>
)
}
Exemple d'interface d'erreur :
// 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'>Quelque chose a mal tourné !</h2>
<Button onClick={reset}>Réessayer</Button>
</div>
)
}
⚡ Performances
Modèles d'optimisation :
- Utiliser les Server Components (bundle plus petit)
- Utiliser
next/imagepour les images - Utiliser
next/fontpour les polices - Charger paresseusement les Client Components lorsque c'est possible
- Utiliser
useMemoetuseCallbackdans les Client Components - Streamer les données avec les limites Suspense
Optimisation des images :
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 avec 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
Normes :
- Mode strict activé
- Pas de type
any - Types de retour explicites sur les fonctions
- Imports de types :
import type { Post } from '@/types/post' - Interfaces de props de composant avec JSDoc
Exemple :
import type { ComponentProps } from 'react'
import { Button } from '@/components/ui/button'
/**
* Composant bouton personnalisé avec état de chargement
*/
interface CustomButtonProps extends ComponentProps<typeof Button> {
isLoading?: boolean
}
export function CustomButton({
isLoading,
children,
...props
}: CustomButtonProps) {
return (
<Button disabled={isLoading} {...props}>
{isLoading ? 'Chargement...' : children}
</Button>
)
}
🔧 Modèles courants
Gestion des formulaires :
- Utiliser les Server Actions pour les soumissions de formulaires
- Utiliser
react-hook-formaveczodpour la validation (Client Components) - Utiliser les composants Formulaire de Shadcn/ui
Exemple de formulaire avec Server Action :
// 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)
// ... logique de création de l'article
redirect('/posts')
}
Métadonnées :
import { Metadata } from 'next'
export const metadata: Metadata = {
title: 'Articles',
description: 'Liste de tous les articles',
openGraph: {
title: 'Articles',
description: 'Liste de tous les articles',
},
}
Principes fondamentaux
- Server Components en premier : Par défaut, utiliser les Server Components, utiliser les Client Components uniquement lorsque nécessaire
- Structure App Router : Utiliser le routage basé sur les fichiers avec le répertoire
app/ - Composants Shadcn/ui : Utiliser des composants accessibles pré-construits
- Tailwind CSS : Stylisation utilitaire avec l'aide de
cn() - TypeScript strict : Pas de
any, types explicites - Performances : Utiliser les Server Components, optimiser les images, charger paresseusement lorsque nécessaire
- Organisation des fichiers : Fonctionnalités dans
app/features/, partagées danscomponents/ - Alias d'import : Utiliser le préfixe
@/pour des imports propres
Référence rapide : Structure des fichiers
app/
layout.tsx # Mise en page racine
page.tsx # Page d'accueil
globals.css # Styles globaux
(routes)/
posts/
page.tsx # Page de liste des articles
[id]/
page.tsx # Page de détail d'un article
loading.tsx # Interface de chargement
error.tsx # Interface d'erreur
features/
posts/
components/
PostList.tsx # Composants de la fonctionnalité
actions/
posts.ts # Server Actions
components/
ui/ # Composants Shadcn/ui
button.tsx
card.tsx
lib/
utils.ts # Utilitaires (cn, etc.)
hooks/
use-mobile.ts # Hooks personnalisés
Modèle de composant moderne (Copie rapide)
Server Component :
// 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 Component :
// 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>
<Input value={title} onChange={(e) => setTitle(e.target.value)} />
<Button type='submit'>Soumettre</Button>
</form>
)
}