Cours Next.js · Module 5: Stratégies de rendu
Le prérendu partiel (Partial Prerendering)
Dans cette leçon11
Dans les modules précédents, nous avons abordé différentes stratégies de rendu dans Next.js, notamment le streaming de données et la mise en place des états de chargement. Dans ce module, nous allons nous concentrer sur une des fonctionnalités les plus récentes et les plus intéressantes de Next.js : le Partial Prerendering (PPR), qui combine les avantages de la génération statique et du rendu dynamique au sein d'une seule approche hybride.
Qu'est-ce que le Partial Prerendering ?
Le Partial Prerendering (PPR) est un modèle de rendu introduit dans Next.js 14 qui permet de générer statiquement certaines parties d'une page au moment du build, tandis que d'autres parties peuvent être rendues dynamiquement au moment de la requête.
Pour le dire simplement, le PPR permet :
- Un rendu instantané des parties statiques de la page (par ex. le layout, le template, les en-têtes)
- Un rendu différé des parties dynamiques qui nécessitent des données fraîches
Cette architecture hybride combine les avantages des deux mondes : la rapidité de la génération statique et la fraîcheur du rendu dynamique.
Les problèmes que résout le Partial Prerendering
Avant l'arrivée du PPR, les développeurs devaient choisir entre plusieurs approches, chacune avec ses propres limites :
- Static Site Generation (SSG) - une livraison de contenu rapide, mais des soucis de fraîcheur des données
- Server-Side Rendering (SSR) - des données toujours à jour, mais un TTFB (Time To First Byte) plus lent
- Incremental Static Regeneration (ISR) - un compromis entre SSG et SSR, mais avec des contraintes de temps
- Client-Side Rendering (CSR) - de l'interactivité au prix des performances SEO
Le PPR cherche à résoudre ces problèmes en introduisant un nouveau modèle hybride, dans lequel ces approches peuvent coexister sur une même page de façon plus intégrée.
Comment fonctionne le Partial Prerendering ?
Le PPR introduit une nouvelle unité de rendu : des « hole » (trous) ou des « slots » (emplacements), placés dans le contenu généré statiquement. Ces trous sont ensuite remplis par du contenu rendu dynamiquement côté client.
Ce processus peut être découpé en quatre étapes :
- Le rendu préalable statique - au moment du build, Next.js génère un Shell HTML statique avec des « trous » pour les parties dynamiques
- La réponse instantanée - lorsque l'utilisateur demande la page, le serveur répond immédiatement avec le contenu préalablement rendu du Shell
- Le remplissage dynamique - les « trous » sont remplis de façon asynchrone par des données dynamiques côté serveur
- Le streaming du contenu - le contenu dynamique est streamé vers le navigateur au fur et à mesure de son rendu
Mettre en œuvre le Partial Prerendering dans Next.js
1. Configuration du PPR dans Next.js
Dans Next.js 16, le PPR fait partie des Cache Components et tu l'actives avec une seule option dans le fichier next.config.ts :
// next.config.ts
import type { NextConfig } from 'next';
const nextConfig: NextConfig = {
cacheComponents: true,
};
export default nextConfig;Une fois cette option activée, le PPR fonctionne sur chaque route : tout ce qui peut être rendu au moment du build rejoint la coquille statique, y compris les données issues des fonctions marquées par la directive 'use cache', et les fragments dynamiques enveloppés dans <Suspense> sont envoyés au moment de la requête. Dans Next.js 14 et 15, le PPR était expérimental (uniquement dans les versions canary pour Next.js 15) et s'activait avec le flag experimental.ppr, que Next.js 16 a supprimé :
// next.config.js - Next.js 14-15, ce flag ne fonctionne plus dans Next.js 16
module.exports = {
experimental: {
ppr: true
}
}Dans ces versions, on pouvait aussi activer le PPR uniquement pour certaines routes grâce à l'export experimental_ppr (avec ppr: 'incremental'). Next.js 16 a également supprimé cet export, et une fois cacheComponents activé, les options de segment comme dynamic, dynamicParams, revalidate et fetchCache ne sont plus disponibles :
// Next.js 15 canary (supprimé dans Next.js 16)
export const experimental_ppr = true;2. Exemple de base du PPR
Voici un exemple d'implémentation du PPR dans Next.js 16 (avec cacheComponents activé) :
// app/products/[category]/page.tsx
import { Suspense } from 'react';
import { cacheLife } from 'next/cache';
import { CategoryHeader } from '@/components/category-header';
import { ProductGrid } from '@/components/product-grid';
import { ProductFilters } from '@/components/product-filters';
import { LoadingSkeleton } from '@/components/loading-skeleton';
// Paramètres statiques pour les pages prérendues
export async function generateStaticParams() {
const categories = await fetchTopCategories();
return categories.map(category => ({ category: category.slug }));
}
// Données statiques connues au moment du build
async function getCategoryData(categorySlug: string) {
'use cache';
cacheLife('days');
// Récupère les données de base de la catégorie, qui changent rarement.
// Grâce à 'use cache', les données seront récupérées au moment du build
// et feront partie du Shell statique
const data = await fetch(`https://api.example.com/categories/${categorySlug}`);
return data.json();
}
export default async function CategoryPage({
params,
searchParams,
}: {
params: Promise<{ category: string }>;
searchParams: Promise<Record<string, string>>;
}) {
// Récupère les données statiques de la catégorie (rendues au moment du build)
const categoryData = await getCategoryData((await params).category);
return (
<div className="container mx-auto py-8">
{/* En-tête rendu statiquement - partie du Shell */}
<CategoryHeader category={categoryData} />
<div className="grid grid-cols-4 gap-6 mt-8">
<div className="col-span-1">
{/* Filtres rendus dynamiquement, avec des données dépendant de la session utilisateur */}
<Suspense fallback={<LoadingSkeleton type="filters" />}>
<ProductFilters categorySlug={(await params).category} />
</Suspense>
</div>
<div className="col-span-3">
{/* Liste de produits rendue dynamiquement, avec des données fraîches */}
<Suspense fallback={<LoadingSkeleton type="products" />}>
<ProductGrid categorySlug={(await params).category} searchParams={searchParams} />
</Suspense>
</div>
</div>
</div>
);
}Dans le composant ProductFilters et ProductGrid, on utilisera l'option cache: 'no-store' pour garantir que les données soient toujours fraîches :
// components/product-grid.tsx
async function getProducts(categorySlug: string, filterParams?: Record<string, string>) {
// On crée une URL avec les paramètres de filtre
const queryParams = new URLSearchParams(filterParams);
const url = `https://api.example.com/products?category=${categorySlug}&${queryParams}`;
// On utilise l'option no-store pour toujours récupérer des données fraîches
const res = await fetch(url, { cache: 'no-store' });
if (!res.ok) {
throw new Error('Failed to fetch products');
}
return res.json();
}
export async function ProductGrid({
categorySlug,
searchParams,
}: {
categorySlug: string;
searchParams: Promise<Record<string, string>>;
}) {
// Les paramètres de filtrage de l'URL ne sont lus qu'ici, à l'intérieur de <Suspense>
const filterParams = await searchParams;
// Récupère les produits en tenant compte des filtres
const products = await getProducts(categorySlug, filterParams);
return (
<div className="grid grid-cols-3 gap-4">
{products.map(product => (
<ProductCard key={product.id} product={product} />
))}
</div>
);
}Remarque : searchParams arrive dans ProductGrid sous forme de promesse et n'est lu qu'à l'intérieur de la frontière <Suspense>. Grâce à cela, l'en-tête de catégorie et les squelettes de chargement restent dans la coquille statique, et seule la liste de produits est dynamique. Tu n'utiliseras pas du tout le hook useSearchParams ici, car il ne fonctionne que dans les composants clients.
Modèles avancés de PPR
1. Éviter la cascade de requêtes avec un préchargeur
Un des problèmes du rendu asynchrone est la « cascade de requêtes », que l'on peut limiter grâce au préchargement :
// app/products/[category]/page.tsx
import { Suspense } from 'react';
import { ProductGrid } from './product-grid';
// Fonction de préchargement qui déclenche le chargement des données
function preloadProducts(categorySlug: string) {
// Déclenche la récupération des données, mais n'attend pas le résultat
void getProducts(categorySlug);
}
export default async function CategoryPage({ params }: { params: Promise<{ category: string }> }) {
// Démarre le chargement des données plus tôt
preloadProducts((await params).category);
return (
<div>
{/* En-tête prérendu statiquement */}
<h1>Catégorie : {(await params).category}</h1>
{/* Partie dynamique */}
<Suspense fallback={<div>Chargement des produits...</div>}>
<ProductGrid categorySlug={(await params).category} />
</Suspense>
</div>
);
}
// Voici à quoi ressemble la fonction getProducts dans ce cas
async function getProducts(categorySlug: string) {
// Fonction avec mise en cache des résultats
// On peut utiliser la bibliothèque SWR ou React Query pour une mise en cache plus avancée
const cacheKey = `products-${categorySlug}`;
if (!cache.has(cacheKey)) {
const promise = fetch(`https://api.example.com/products?category=${categorySlug}`, {
cache: 'no-store'
}).then(res => res.json());
cache.set(cacheKey, promise);
}
return cache.get(cacheKey);
}2. Définir la priorité de chargement des sections
On peut définir la priorité de chargement des différentes parties de la page grâce à des composants Suspense imbriqués :
// app/dashboard/page.tsx
import { Suspense } from 'react';
import { Header } from '@/components/header';
import { UserWidget } from '@/components/user-widget';
import { RecentActivity } from '@/components/recent-activity';
import { PerformanceMetrics } from '@/components/performance-metrics';
import { Recommendations } from '@/components/recommendations';
import {
UserWidgetSkeleton,
RecentActivitySkeleton,
PerformanceMetricsSkeleton,
RecommendationsSkeleton
} from '@/components/skeletons';
export default function DashboardPage() {
return (
<div className="container mx-auto py-8">
{/* Partie statique - en-tête */}
<Header title="Dashboard" />
<div className="grid grid-cols-12 gap-6 mt-8">
{/* Priorité 1 : widget utilisateur - chargé en premier */}
<div className="col-span-3">
<Suspense fallback={<UserWidgetSkeleton />}>
<UserWidget />
</Suspense>
</div>
<div className="col-span-9">
{/* Priorité 2 : activité récente - chargée en second */}
<Suspense fallback={<RecentActivitySkeleton />}>
<RecentActivity />
<div className="grid grid-cols-2 gap-6 mt-6">
{/* Priorité 3 : métriques de performance - chargées en troisième */}
<Suspense fallback={<PerformanceMetricsSkeleton />}>
<PerformanceMetrics />
</Suspense>
{/* Priorité 4 : recommandations - chargées en dernier */}
<Suspense fallback={<RecommendationsSkeleton />}>
<Recommendations />
</Suspense>
</div>
</Suspense>
</div>
</div>
</div>
);
}3. Paramètres dynamiques avec le Partial Prerendering
On peut combiner génération statique et paramètres dynamiques :
// app/products/[id]/page.tsx
import { Suspense } from 'react';
// On ne génère statiquement que certaines pages de produits
export async function generateStaticParams() {
// On ne récupère que les produits populaires à prérendre
const popularProducts = await fetchPopularProducts();
return popularProducts.map(product => ({
id: product.id.toString()
}));
}
// Une fois dynamicParams: true activé, les produits sans génération statique
// seront rendus à la demande
export const dynamicParams = true;
export default async function ProductPage({ params }: { params: Promise<{ id: string }> }) {
// Cette fonction récupère les informations de base du produit
// Pour les produits populaires, ces données seront récupérées au moment du build
// Pour les autres, au moment de la requête
const product = await getProductBasicInfo((await params).id);
if (!product) {
return <div>Produit introuvable</div>;
}
return (
<div className="product-page">
<h1>{product.name}</h1>
<div className="product-image">
<img src={product.imageUrl} alt={product.name} />
</div>
<div className="product-info">
<p className="product-price">{product.price} €</p>
{/* Partie dynamique avec des informations toujours à jour */}
<Suspense fallback={<div>Vérification de la disponibilité...</div>}>
<ProductAvailability productId={(await params).id} />
</Suspense>
<Suspense fallback={<div>Chargement des options de livraison...</div>}>
<DeliveryOptions productId={(await params).id} />
</Suspense>
</div>
<div className="product-details">
{/* Partie statique - description du produit */}
<div dangerouslySetInnerHTML={{ __html: product.description }} />
{/* Partie dynamique - avis, mis à jour fréquemment */}
<Suspense fallback={<div>Chargement des avis...</div>}>
<ProductReviews productId={(await params).id} />
</Suspense>
</div>
</div>
);
}
async function getProductBasicInfo(id: string) {
// Récupération des informations de base du produit
// Peut être mis en cache, car ces informations changent rarement
const res = await fetch(`https://api.example.com/products/${id}/basic`);
if (!res.ok) return null;
return res.json();
}4. Routage dynamique avec le Partial Prerendering
On peut aussi utiliser le PPR avec des routes dynamiques, par exemple pour un filtrage avancé :
// app/products/[[...slug]]/page.tsx
import { Suspense } from 'react';
// On génère les combinaisons populaires de filtres/catégories à prérendre
export async function generateStaticParams() {
return [
{ slug: [] }, // /products
{ slug: ['category', 'electronics'] }, // /products/category/electronics
{ slug: ['deals'] }, // /products/deals
// ... autres combinaisons populaires
];
}
export const dynamicParams = true; // Permet le rendu dynamique des autres combinaisons
export default async function ProductsPage({ params }: { params: Promise<{ slug?: string[] }> }) {
// Analyse des paramètres slug
const { category, filters } = parseSlug((await params).slug || []);
// Récupération des métadonnées statiques
const pageMetadata = await getPageMetadata(category);
return (
<div className="container mx-auto py-8">
{/* Partie statique - en-tête et métadonnées */}
<h1>{pageMetadata.title}</h1>
<p>{pageMetadata.description}</p>
<div className="flex mt-8">
{/* Partie dynamique - filtres */}
<div className="w-1/4">
<Suspense fallback={<div>Chargement des filtres...</div>}>
<ProductFilters category={category} activeFilters={filters} />
</Suspense>
</div>
{/* Partie dynamique - liste de produits */}
<div className="w-3/4">
<Suspense fallback={<div>Chargement des produits...</div>}>
<ProductList category={category} filters={filters} />
</Suspense>
</div>
</div>
</div>
);
}
// Fonction utilitaire pour analyser les paramètres slug
function parseSlug(slug: string[]) {
let category = '';
const filters: Record<string, string> = {};
for (let i = 0; i < slug.length; i += 2) {
if (slug[i] === 'category' && slug[i+1]) {
category = slug[i+1];
} else if (slug[i] && slug[i+1]) {
filters[slug[i]] = slug[i+1];
}
}
return { category, filters };
}La mise en cache des données dans le PPR
Une mise en cache optimale des données est essentielle pour les performances du PPR. Voici quelques modèles de mise en cache :
1. La mise en cache au niveau de React
// utils/cache.ts
export const dataCache = new Map();
export async function getCachedData(key: string, fetcher: () => Promise<any>) {
if (!dataCache.has(key)) {
try {
const promise = fetcher();
dataCache.set(key, promise);
const data = await promise;
return data;
} catch (error) {
dataCache.delete(key);
throw error;
}
}
return dataCache.get(key);
}Utilisation :
// components/product-list.tsx
import { getCachedData } from '@/utils/cache';
async function getProducts(category: string) {
return getCachedData(`products-${category}`, () => {
return fetch(`https://api.example.com/products?category=${category}`, {
cache: 'no-store'
}).then(res => res.json());
});
}2. La mémoïsation des fonctions de récupération de données
// lib/fetch-client.ts
import { cache } from 'react';
// On utilise la mémoïsation de React pour mettre en cache les résultats des requêtes
export const fetchAPI = cache(async (url: string, options: RequestInit = {}) => {
const res = await fetch(url, options);
if (!res.ok) {
throw new Error(`Failed to fetch ${url}`);
}
return res.json();
});Utilisation :
// components/product-data.tsx
import { fetchAPI } from '@/lib/fetch-client';
export async function ProductData({ id }: { id: string }) {
// La requête ne sera exécutée qu'une seule fois par rendu,
// même si le composant est utilisé plusieurs fois avec le même id
const product = await fetchAPI(`https://api.example.com/products/${id}`);
return (
<div className="product-data">
<h2>{product.name}</h2>
<p>{product.description}</p>
<p className="price">{product.price} €</p>
</div>
);
}Exemples d'utilisation du PPR selon le scénario
1. E-commerce
Le PPR est idéal pour les pages produit d'un site e-commerce, où l'on peut :
- Prérendre les éléments statiques : nom du produit, images, description, spécifications
- Rendre dynamiquement : le stock disponible, les prix promotionnels, les avis clients
2. Portails d'actualités
Pour les sites d'actualités, le PPR permet :
- De prérendre le template de la page, les titres d'articles et les sections fixes
- De rendre dynamiquement les recommandations personnalisées et les dernières actualités
3. Tableaux de bord d'application
Pour les tableaux de bord analytiques :
- Prérendre la structure du tableau de bord, les contrôles et l'interface utilisateur
- Rendre dynamiquement les graphiques et les données analytiques propres à chaque utilisateur
Déboguer et surveiller le PPR
Déboguer le PPR peut être exigeant en raison de la nature hybride du rendu. Voici quelques pistes :
1. Utiliser React DevTools
React DevTools permet d'inspecter les composants et leur état de rendu.
2. Déboguer la génération statique
NEXT_DEBUG=1 next buildCette commande affiche des informations détaillées sur les pages qui sont générées statiquement.
3. Surveiller l'environnement de production
Mets en place des outils de suivi des performances, comme Lighthouse, PageSpeed Insights ou des outils de monitoring des Core Web Vitals, pour évaluer l'impact du PPR sur l'expérience de l'utilisateur final.
Limites et points de vigilance
- Une fonctionnalité expérimentale - le PPR est encore une fonctionnalité expérimentale et peut évoluer
- Les environnements pris en charge - le PPR fonctionne mieux avec Node.js et le edge runtime
- La complexité du modèle mental - le modèle de rendu hybride peut être plus difficile à comprendre et à déboguer
- Une utilisation optimale - le PPR n'est pas toujours le meilleur choix : pour des pages statiques simples, le SSG peut être plus simple et plus performant
Bonnes pratiques
1. Équilibrer contenu statique et contenu dynamique
Détermine clairement quelles données peuvent être rendues statiquement et lesquelles doivent être dynamiques :
- Statique : interface utilisateur, métadonnées fixes, contenus rarement mis à jour
- Dynamique : données personnalisées, informations fréquemment mises à jour, données dépendant du contexte utilisateur
2. Prioriser le chargement
Utilise des Suspense imbriqués pour prioriser le chargement du contenu :
- Charge en premier les données critiques pour le métier
- Tu peux charger les sections moins importantes plus tard
3. Gérer le cache efficacement
Gère soigneusement la mise en cache des données pour éviter des rendus inutiles :
- Utilise
fetchAPIavec la mémoïsation de React - Applique une invalidation du cache avec revalidatePath et revalidateTag
4. Des squelettes de chargement adaptés
Conçois des squelettes de chargement qui respectent les dimensions et les proportions du contenu final, afin de limiter les décalages de mise en page.
Résumé
Le Partial Prerendering (PPR) est une fonctionnalité puissante de Next.js qui permet de combiner la performance de la génération statique avec la flexibilité du rendu dynamique. Il devient ainsi possible de créer des applications rapides et interactives, avec des performances optimales pour différents types de contenu.
Les principaux avantages du PPR sont :
- Un TTFB plus rapide - les parties statiques sont livrées instantanément
- De meilleures performances SEO - le contenu critique est prérendu statiquement
- Une expérience utilisateur optimale - un template stable limite le scintillement pendant le chargement du contenu dynamique
- De la flexibilité - il est facile de combiner différentes stratégies de rendu au sein d'une même application
Même si le PPR est encore en phase expérimentale, il offre une vision enthousiasmante de l'avenir du rendu dans Next.js, en réunissant les avantages d'approches jusque-là dispersées pour la génération de contenu web.
Dans le prochain module, nous verrons en détail la gestion du cache et les techniques avancées de revalidation des données, essentielles au bon fonctionnement du PPR et des autres stratégies de rendu dans Next.js.
Code de cette leçon : App.tsx
import React, { useState, useEffect } from 'react';
// Partial Prerendering (PPR) - simulation dans Next.js
// La partie statique est rendue immédiatement, la partie dynamique est streamée plus tard
function StaticShell() {
return (
<div style={{ background: '#1a2744', borderRadius: 8, padding: 16, border: '1px solid #64ffda' }}>
<h3 style={{ color: '#64ffda', margin: 0 }}>Shell statique (prerendered)</h3>
<p style={{ color: '#aaa', fontSize: 13, margin: '8px 0 0' }}>
La navigation, le layout et les métadonnées sont disponibles immédiatement.
Cette partie de la page est générée au build time.
</p>
</div>
);
}
function DynamicSection({ label, delay }: { label: string; delay: number }) {
const [data, setData] = useState<string | null>(null);
useEffect(() => {
const t = setTimeout(() => setData(`Données dynamiques : ${label} (chargées après ${delay}ms)`), delay);
return () => clearTimeout(t);
}, [label, delay]);
if (!data) {
return (
<div style={{ background: '#0d1117', borderRadius: 8, padding: 16, border: '1px dashed #555' }}>
<div style={{ color: '#888', fontSize: 13 }}>Streaming: {label}...</div>
<div style={{
height: 10, background: 'linear-gradient(90deg, #333, #555, #333)',
backgroundSize: '200% 100%', borderRadius: 4, marginTop: 8,
animation: 'shimmer 1.5s ease-in-out infinite'
}} />
</div>
);
}
return (
<div style={{ background: '#1b5e20', borderRadius: 8, padding: 16, border: '1px solid #4caf50' }}>
<div style={{ color: '#4caf50', fontWeight: 'bold', fontSize: 13 }}>DYNAMIC</div>
<div style={{ color: '#e0e0e0', marginTop: 4 }}>{data}</div>
</div>
);
}
export default function PPRDemo() {
const [key, setKey] = useState(0);
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: 20, color: '#e0e0e0', fontFamily: 'monospace' }}>
<style>{`@keyframes shimmer { 0% { background-position: 200% 0; } 100% { background-position: -200% 0; } }`}</style>
<h1 style={{ color: '#64ffda' }}>Partial Prerendering (PPR)</h1>
<p style={{ color: '#888' }}>
Le shell statique se charge immédiatement, les sections dynamiques se streament indépendamment.
</p>
<button onClick={() => setKey(k => k + 1)} style={{
background: '#9c27b0', color: '#fff', border: 'none', borderRadius: 6,
padding: '8px 16px', cursor: 'pointer', margin: '12px 0', fontFamily: 'monospace'
}}>
Simuler un rechargement
</button>
<div key={key} style={{ display: 'flex', flexDirection: 'column', gap: 12 }}>
<StaticShell />
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 12 }}>
<DynamicSection label="Panier utilisateur" delay={800} />
<DynamicSection label="Recommandations" delay={2000} />
</div>
<DynamicSection label="Commentaires de la communauté" delay={3000} />
</div>
</div>
);
}Entrées de la documentation utilisées dans cette leçon
Tu as repéré une erreur dans cette leçon ?
Teste tes connaissances
Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.
1. Le streaming dans Next.js permet :
2. Les frontières Suspense dans React servent à :
Tâches pratiques dans le jeu
- Éditeur de code
Crée les composants loading.tsx et error.tsx pour une gestion élégante des états de chargement et d'erreur
- Tri vertical
Place les étapes de revalidation ISR (Incremental Static Regeneration) dans le bon ordre :
- Clique dans l'ordre
Reconstitue la syntaxe de la fonction generateStaticParams dans Next.js
- Éditeur de code
Crée une application combinant des Server Components (header, footer) avec des Client Components (formulaire interactif)
Exercices après cette leçon
- QuestionLe streaming dans Next.js permet :
- QuestionLes frontières Suspense dans React servent à :
- Exercice de codePratique : Crée les composants loading.tsx et error.tsx
- Remets dans l'ordreFlux de revalidation ISR
- Clique dans l'ordreSyntaxe de generateStaticParams
- Exercice de codePratique : Crée une application combinant des Server Components