Plusieurs pages : du routeur à Nuxt
Slides
Plusieurs pages, du routeur à Nuxt : la théorie en quatorze slides (PDF)PDF
Objectif : comprendre à quoi sert un routeur, voir ce que Vue Router demande d'écrire à la main, puis créer une page dans Nuxt en ajoutant un seul fichier.
L'exemple de ce chapitre est Kawa, un torréfacteur de quartier à Wavre. Son site a quatre sortes de pages : l'accueil, la liste des cafés, la fiche d'un café et le contact. Il est construit avec Vue Router, puis avec Nuxt : seule la façon de ranger les pages change.
Tu as déjà choisi ta piste et écrit tes règles de design. Ce chapitre explique l'outil avec lequel ton agent va construire le site, dans l'atelier « Construire le site avec Nuxt ».
1. Avant : plusieurs fichiers HTML
En HTML, chaque page est un fichier, et des liens les relient.
kawa-html/
├── index.html
├── cafes.html
└── contact.html
Dans chacun des trois fichiers, le même menu :
<nav>
<a href="index.html">Accueil</a>
<a href="cafes.html">Nos cafés</a>
<a href="contact.html">Contact</a>
</nav>
Quand tu cliques sur « Contact », le navigateur demande le fichier contact.html au serveur et affiche la nouvelle page en entier, menu compris.
Ce système marche. Son défaut : le menu est recopié dans chaque fichier, et un lien de plus se retouche partout.
2. Une application Vue n'a qu'un fichier HTML
Ouvre un projet Vue : il n'y a qu'un index.html, avec un <div id="app"> vide. Tout le reste est dans des composants. C'est ce que tu as vu au chapitre « Structure d'un projet Vue ».
Une fois construit avec npm run build, le projet n'a toujours qu'un fichier HTML, dans dist/ :
dist/
├── assets/
│ ├── index-BlWeQzsc.css
│ └── index-D2fxbEG-.js
├── favicon.ico
└── index.html
Dans cette démonstration, le serveur renvoie ce même index.html pour l'adresse / comme pour /contact. C'est à l'application de décider quoi afficher.
Elle a besoin d'un routeur. Il lit l'adresse dans la barre du navigateur et affiche le composant qui lui correspond. Au clic sur un lien, il change l'adresse et le composant, sans redemander de page au serveur.

3. Avec Vue Router, à la main
Vue a un routeur officiel : Vue Router. Un projet créé avec npm create vue@latest ne l'a pas, sauf si tu coches l'option. Tu n'écriras pas le code de cette section : il montre ce que Nuxt t'évite.
Installer et ranger les pages
Vue Router est un paquet : du code prêt à l'emploi, qu'on ajoute au projet avec npm.
npm install vue-router
Chaque page devient un composant, rangé par habitude dans src/views/ :
src/
├── assets/
│ └── main.css
├── data/
│ └── cafes.json
├── router/
│ └── index.js
├── views/
│ ├── HomeView.vue
│ ├── CafesView.vue
│ ├── CafeView.vue
│ └── ContactView.vue
├── App.vue
└── main.js
Écrire la table des routes
Le fichier src/router/index.js contient la table qui relie chaque adresse à un composant :
import { createRouter, createWebHistory } from 'vue-router'
import HomeView from '../views/HomeView.vue'
import CafesView from '../views/CafesView.vue'
import CafeView from '../views/CafeView.vue'
import ContactView from '../views/ContactView.vue'
const router = createRouter({
history: createWebHistory(),
routes: [
{ path: '/', component: HomeView },
{ path: '/cafes', component: CafesView },
{ path: '/cafes/:slug', component: CafeView },
{ path: '/contact', component: ContactView },
],
})
export default router
En haut, un import par page. Dans routes, une ligne par adresse : path est l'adresse, component le composant à afficher. createWebHistory() donne des adresses normales, comme /contact.
La troisième route est différente. Dans /cafes/:slug, les deux-points signifient « n'importe quel texte à cet endroit ». Ce texte est rangé sous le nom slug. Un slug est la version d'un nom faite pour une adresse : en minuscules, sans accent, avec des tirets à la place des espaces. Le café Guji a le slug guji. Une seule route sert ainsi pour les quatre cafés.
Brancher le routeur
Dans src/main.js, deux lignes branchent la table sur l'application : l'import du routeur et app.use(router).
import './assets/main.css'
import { createApp } from 'vue'
import App from './App.vue'
import router from './router'
const app = createApp(App)
app.use(router)
app.mount('#app')
Placer les liens et la zone d'affichage
Reste App.vue, le composant qui entoure toutes les pages :
<template>
<header>
<nav>
<RouterLink to="/">Accueil</RouterLink>
<RouterLink to="/cafes">Nos cafés</RouterLink>
<RouterLink to="/contact">Contact</RouterLink>
</nav>
</header>
<main>
<RouterView />
</main>
</template>
RouterLink remplace la balise <a> : au clic, le routeur change de composant sans recharger la page. RouterView marque l'endroit où le composant choisi s'affiche. Le menu, écrit une seule fois, reste en place.
La fiche d'un café
Le composant CafeView.vue lit le slug dans l'adresse, puis cherche le café correspondant dans le JSON. Dans un projet Vue, @ désigne le dossier src/ : @/data/cafes.json est le fichier src/data/cafes.json.
<script setup>
import { useRoute } from 'vue-router'
import cafes from '@/data/cafes.json'
const route = useRoute()
const cafe = cafes.find((c) => c.slug === route.params.slug)
</script>
<template>
<article v-if="cafe">
<h1>{{ cafe.name }}</h1>
<p>Origine : {{ cafe.origin }}</p>
<p>Notes : {{ cafe.notes }}</p>
<p>{{ cafe.price }} les 250 g</p>
</article>
<p v-else>Ce café n'existe pas.</p>
<RouterLink to="/cafes">Retour aux cafés</RouterLink>
</template>
useRoute() donne l'adresse en cours : pour /cafes/guji, route.params.slug vaut 'guji'. find renvoie le premier café dont le slug correspond. Sinon, cafe est vide et le v-else affiche « Ce café n'existe pas. »
Ajouter une page
Kawa demande maintenant une page « Les ateliers ». Avec Vue Router, il faut :
- créer le composant
src/views/AteliersView.vue; - l'importer en haut de
src/router/index.js; - ajouter sa ligne dans la table des routes, dans le même fichier ;
- ajouter son
RouterLinkdans le menu deApp.vue.
Un oubli se paie : avec l'import sans la ligne dans la table, l'adresse /ateliers n'affiche que le menu. Et ce travail revient à chaque page.
4. Avec Nuxt : un fichier, une page
Un framework est un ensemble d'outils et de règles de rangement pour construire un site. Nuxt est un framework construit sur Vue : tu y écris les mêmes composants .vue. Ici, le dossier pages remplace la table des routes.
Le projet a été créé avec le modèle le plus simple, minimal :
npm create nuxt@latest kawa-nuxt -- --template minimal --packageManager npm --no-gitInit --no-modules
Pour le site de ton client, l'agent ajoute Nuxt UI, une bibliothèque de composants, avec --modules ui. Le dossier pages marche de la même façon.
Dans un projet Nuxt 4, ton code vit dans le dossier app/. Voici celui de Kawa :
app/
├── assets/
│ └── css/
│ └── main.css
├── data/
│ └── cafes.json
├── layouts/
│ └── default.vue
├── pages/
│ ├── cafes/
│ │ ├── [slug].vue
│ │ └── index.vue
│ ├── contact.vue
│ └── index.vue
└── app.vue
Le dossier pages est la table des routes
Chaque fichier du dossier pages est une page, et son chemin donne son adresse :
| Fichier | Adresse |
|---|---|
pages/index.vue |
/ |
pages/cafes/index.vue |
/cafes |
pages/cafes/[slug].vue |
/cafes/guji, /cafes/huila… |
pages/contact.vue |
/contact |
Un fichier index.vue donne l'adresse de son dossier. Les crochets de [slug].vue jouent le rôle du :slug de Vue Router : n'importe quel texte à cet endroit, rangé sous le nom slug.

Ces fichiers portent des noms français, alors que le reste du code est en anglais : leur nom devient une adresse que le visiteur lit.
Le layout porte le menu
Un layout est le cadre commun à plusieurs pages : l'en-tête, le menu, le pied de page. Celui de Kawa est app/layouts/default.vue :
<template>
<header>
<nav>
<NuxtLink to="/">Accueil</NuxtLink>
<NuxtLink to="/cafes">Nos cafés</NuxtLink>
<NuxtLink to="/contact">Contact</NuxtLink>
</nav>
</header>
<main>
<slot />
</main>
</template>
NuxtLink joue le rôle de RouterLink. <slot /> marque l'endroit où la page s'affiche, comme RouterView. Le layout default sert à toutes les pages qui n'en demandent pas un autre.
Le fichier app/app.vue place la page en cours dans le layout :
<template>
<NuxtRouteAnnouncer />
<NuxtLayout>
<NuxtPage />
</NuxtLayout>
</template>
NuxtPage affiche la page qui correspond à l'adresse. NuxtLayout l'entoure du layout, ici default.vue. NuxtRouteAnnouncer, déjà présent dans le projet créé, signale chaque changement de page aux lecteurs d'écran.
La fiche d'un café
Le fichier app/pages/cafes/[slug].vue commence ainsi :
<script setup>
import cafes from '~/data/cafes.json'
const route = useRoute()
const cafe = cafes.find((c) => c.slug === route.params.slug)
</script>
L'import de useRoute a disparu : Nuxt le fait lui-même. ~ désigne le dossier app/, comme @ désignait src/. Le <template> est celui de CafeView.vue, avec NuxtLink à la place de RouterLink.

À l'écran, les deux versions du site donnent la même page. Le nombre après localhost: change d'un projet à l'autre.
Ajouter une page, deux façons
La page « Les ateliers » a été ajoutée aux deux versions :
| Pour ajouter une page | Vue Router | Nuxt |
|---|---|---|
| Créer le composant de la page | src/views/AteliersView.vue |
app/pages/ateliers.vue |
| L'importer | une ligne dans src/router/index.js |
rien |
| Déclarer son adresse | une ligne dans src/router/index.js |
rien : le nom du fichier suffit |
| Ajouter le lien au menu | une ligne dans src/App.vue |
une ligne dans app/layouts/default.vue |
| Bilan | 1 fichier créé, 2 fichiers modifiés, 3 lignes ajoutées en plus du composant | 1 fichier créé, 1 fichier modifié, 1 ligne ajoutée en plus du composant |
Le composant de la page fait quatre lignes dans les deux cas.
Dans Nuxt, /ateliers répond dès que le fichier existe, même pendant npm run dev. Le lien du menu sert au visiteur, pas au routeur.

Sous le capot
Nuxt n'a pas remplacé Vue Router : il s'en sert. Les dépendances d'un projet sont les paquets dont il a besoin, listés dans son package.json. Celui du projet Nuxt cite Vue Router :
"dependencies": {
"nuxt": "^4.6.4",
"vue": "^3.5.45",
"vue-router": "^5.4.0"
}
Nuxt lit le dossier pages et écrit lui-même la table des routes de la section 3.
5. Nuxt est un meta-framework
Un meta-framework est un framework construit au-dessus d'un autre : Nuxt part de Vue et ajoute ce qu'il faut pour un site complet. Le routeur par fichiers en est la première pièce. Suivront :
- les images, redimensionnées et compressées pour chaque écran ;
- le contenu en Markdown : des produits ou des articles écrits dans des fichiers texte ;
- le référencement : un titre et une description par page, et le texte déjà envoyé aux moteurs de recherche ;
- un petit backend : du code sur le serveur, par exemple pour recevoir un formulaire de contact.
6. Exercice : du dossier aux adresses
Durée : 5 minutes, sans ordinateur. La partie 2 est facultative.
Partie 1. Voici le dossier pages d'un fleuriste. Écris l'adresse de chaque fichier. Puis réponds : quelle adresse affiche la fiche du bouquet « Pivoines blanches », et que vaut alors route.params.slug ? Que donne l'adresse /infos ? Indice : regarde ce que contient le dossier infos.
pages/
├── bouquets/
│ ├── [slug].vue
│ └── index.vue
├── infos/
│ ├── contact.vue
│ └── livraison.vue
├── equipe.vue
├── index.vue
└── mariages.vue
Partie 2, facultative. Une librairie de quartier veut ces pages : l'accueil, la liste des livres, la fiche d'un livre, la liste des rencontres d'auteurs, la fiche d'une rencontre, le contact et les mentions légales. Écris son dossier pages.
À retenir
- Un site en HTML a un fichier par page. Une application Vue n'a qu'un fichier HTML : un routeur lit l'adresse et choisit le composant à afficher.
- Avec Vue Router, tu écris la table des routes, tu la branches dans
main.js, tu placesRouterViewetRouterLink. Chaque page demande un composant, un import et une ligne dans la table. - Avec Nuxt, un fichier dans
app/pagesest une page, et son chemin donne son adresse.[slug].vuesert pour toutes les fiches d'une liste. - Le layout porte ce qui est commun à toutes les pages,
NuxtLinkfait les liens. - Nuxt utilise Vue Router. Il écrit la table des routes à ta place.
Dans l'atelier suivant, « Construire le site avec Nuxt », ton agent crée ces fichiers pour le site de ton client, et tu vérifies chaque page.