Aller au contenu

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.

L'adresse /cafes/guji entre dans le routeur, dont la table relie /, /cafes, /cafes/:slug et /contact à HomeView, CafesView, CafeView et ContactView ; la ligne /cafes/:slug est surlignée ; sur la page, le menu Accueil, Nos cafés, Contact reste en place et la zone en dessous affiche CafeView, titré Guji

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 :

  1. créer le composant src/views/AteliersView.vue ;
  2. l'importer en haut de src/router/index.js ;
  3. ajouter sa ligne dans la table des routes, dans le même fichier ;
  4. ajouter son RouterLink dans le menu de App.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.

Le dossier pages de Kawa et l'adresse de chaque fichier : le fichier slug.vue, dont le nom est entre crochets, donne /cafes/guji, cafes/index.vue donne /cafes, contact.vue donne /contact, index.vue donne / ; le mot slug et guji sont surlignés de la même couleur

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.

La fiche du café Guji à l'adresse localhost:3200/cafes/guji : sous le menu Accueil, Nos cafés, Contact, le titre Guji, l'origine Éthiopie, les notes agrumes et jasmin, et le prix de 11,00 euros les 250 g

À 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.

La page Les ateliers à l'adresse localhost:3200/ateliers : le lien Les ateliers, en gras, a rejoint le menu, au-dessus du texte sur l'atelier du samedi

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.

Partie 1

Fichier Adresse
bouquets/[slug].vue /bouquets/…, une adresse par bouquet
bouquets/index.vue /bouquets
infos/contact.vue /infos/contact
infos/livraison.vue /infos/livraison
equipe.vue /equipe
index.vue /
mariages.vue /mariages

La fiche des « Pivoines blanches » s'affiche par exemple à /bouquets/pivoines-blanches, et route.params.slug vaut alors 'pivoines-blanches'.

L'adresse /infos donne une erreur 404 : le dossier infos n'a pas de fichier index.vue.

Partie 2

pages/
├── livres/
│   ├── [slug].vue
│   └── index.vue
├── rencontres/
│   ├── [slug].vue
│   └── index.vue
├── contact.vue
├── index.vue
└── mentions-legales.vue

Les noms peuvent varier. Ce qui compte : un index.vue par liste, un [slug].vue par fiche, et des noms sans accent ni espace.

À 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 places RouterView et RouterLink. Chaque page demande un composant, un import et une ligne dans la table.
  • Avec Nuxt, un fichier dans app/pages est une page, et son chemin donne son adresse. [slug].vue sert pour toutes les fiches d'une liste.
  • Le layout porte ce qui est commun à toutes les pages, NuxtLink fait 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.