Routage Vue3 (Vue Router)
Dans ce chapitre, nous présenterons le routage Vue.
Le routage Vue nous permet d'accéder à différents contenus via différentes URL.
Avec Vue, nous pouvons implémenter des applications web monopages (SPA) multi-vues.
Le routage Vue.js nécessite le chargement de la bibliothèquevue-router
URL de la documentation chinoise :documentation vue-router。
Vue Router est responsable de la correspondance entre les chemins d'URL et les composants de l'application. Lorsque les utilisateurs naviguent dans l'application, l'URL est mise à jour mais la page ne se recharge pas, offrant une expérience utilisateur fluide.

La figure ci-dessus montre unestructure de routes imbriquées à deux niveaux:
- de premier niveau (
App.vuede<router-view>)responsable du rendude mises en page autonomes(commeLogin.vue) oumise en page du cadre principal(Layout.vue)。 - mise en page du cadre principal (
Layout.vue)contient en interne un second<router-view>, utilisé pour rendreles composants enfants de la page de fonctionnalité(commeDashboard.vue、User.vue), permettant ainsi un affichage persistant de l'en-tête, de la barre latérale et du pied de page. - Les chemins sans correspondance finiront par mener à un
page404.vue。
Composants principaux
| Composant | Description | Accès à l'API Options | Accès à l'API Composition |
|---|---|---|---|
routerInstance |
Une instance de l'ensemble du système de routage, utilisée pour la navigation globale, l'ajout de routes, etc. | this.$router |
useRouter() |
routeObject |
L'objet d'état de route actuellement actif, contenant des informations telles que l'URL actuelle, les paramètres, la requête, etc. | this.$route |
useRoute() |
<router-link> |
Un composant utilisé pour la navigation dans l'application ; il sera rendu comme une<a>balise, mais peut empêcher le rechargement par défaut de la page. |
- | - |
<router-view> |
Le composant correspondant à la route sera rendu à cet emplacement. | - | - |
Installation
Installation npm
npm install vue-router
npm (miroir chinois)
Il est recommandé d'utiliser le miroir Taobao :
npm install -g cnpm --registry=https://registry.npmmirror.com cnpm install vue-router@4
Téléchargement direct / CDN
https://unpkg.com/vue-router@4
Utilisation de base
1. Créer une table de routage
// src/router/index.js
import { createRouter, createWebHistory } from 'vue-router'
import Home from '../views/Home.vue'
import About from '../views/About.vue'
const routes = [
{ path: '/', component: Home },
{ path: '/about', component: About }
]
export default createRouter({
history: createWebHistory(),
routes
})
2. Monter dans l'application
// main.js
import { createApp } from 'vue'
import App from './App.vue'
import router from './router'
createApp(App).use(router).mount('#app')
3. Sortie de page
<router-view></router-view>
4. Navigation
<router-link to="/about">About</router-link>
5. Routage dynamique
{ path: '/user/:id', component: User }
En visitant /user/10, $route.params.id === '10'.
6. Chargement différé
const About = () => import('../views/About.vue')
7. Gardiens de navigation (Authentification)
router.beforeEach((to, from, next) => {
next()
})
8. Redirection
{ path: '/old', redirect: '/' }
9、404
{ path: '/:pathMatch(.*)*', component: NotFound }
Exemple simple
Vue.js + vue-router permettent de mettre en œuvre facilement une application monopage.
<router-link>est un composant utilisé pour configurer un lien de navigation afin de basculer entre différents contenus HTML.toL'attribut `to` est l'adresse cible, c'est-à-dire le contenu à afficher.
Dans l'exemple suivant, nous ajoutons vue-router, puis configurons les correspondances des composants et des routes, puis indiquons à vue-router où les afficher. Le code est le suivant :
Code HTML
router-link
Notez que nous n'avons pas utilisé une balise `<a>` classique, mais plutôt un composant personnalisé `router-link` pour créer des liens. Cela permet à Vue Router de modifier l'URL sans recharger la page et de gérer la génération et l'encodage des URL. Nous verrons plus tard comment tirer parti de ces fonctionnalités.
router-view
`router-view` affichera le composant correspondant à l'URL. Vous pouvez le placer n'importe où pour l'adapter à votre mise en page.
Code JavaScript
Essayez-le »
Les liens de navigation cliqués se verront ajouter des stylesclass ="router-link-exact-active router-link-active"。
Exemple d'application
L'exemple suivant couvre les étapes du routage :Définition、Création、Montage、NavigationetRenducinq étapes essentielles.
1. main.js (fichier d'entrée)
Exemple
import App from './App.vue';
import router from './router'; // Importer l'instance de routeur configurée
// 1. Créer une instance d'application Vue
const app = createApp(App);
// 2. Monter le routeur
app.use(router);
// 3. Monter dans le DOM
app.mount('#app');
2. router/index.js (configuration des routes)
Exemple
// Importer les composants de route (utilisation d’imports synchrones pour simplifier l’exemple)
const Home = { template: '<h2>Page d’accueil</h2><p>Bienvenue sur la page d’accueil de l’application !</p>' };
const About = { template: '<h2>À propos de nous</h2><p>En savoir plus sur ce projet.</p>' };
// Définir le tableau des enregistrements de route
const routes = [
{
path: '/',
name: 'Home',
component: Home
},
{
path: '/about',
name: 'About',
component: About
},
// correspondance 404 (à mettre en dernier)
{
path: '/:pathMatch(.*)*',
name: 'NotFound',
component: { template: '<div>404 Non trouvé</div>' }
}
];
// Créer l'instance du routeur
const router = createRouter({
// Utiliser le mode historique HTML5 (recommandé)
history: createWebHistory(),
routes, // Configuration des routes
});
export default router;
3. App.vue (composant racine)
Exemple
<div>
<h1>Exemple de Vue Router</h1>
<nav>
<router-link to="/" active-class="active-link">Accueil</router-link> |
<router-link to="/about" active-class="active-link">À propos</router-link> |
<router-link to="/nonexistent">404 Démo</router-link>
</nav>
<hr>
<main>
<router-view></router-view>
</main>
</div>
</template>
<style>
/* Styles actifs simples */
.active-link {
font-weight: bold;
color: #427EB9; /* Vert Vue */
}
/* Ajuster l'espacement des liens */
nav a {
margin: 0 5px;
text-decoration: none;
}
</style>
Lorsque vous exécutez cette application :
- Cliquez sur le lienHome, l'URL devient
/,<router-view>s'affiche dansHome Pagele contenu du composant. - Cliquez sur le lienAbout, l'URL devient
/about,<router-view>s'affiche dansAbout Usle contenu du composant. - Cliquez sur le lien404 Demo, l'URL devient
/nonexistent,<router-view>s'affiche dans404 Not Foundle contenu du composant.
Attributs associés à <router-link>
Ensuite, apprenons-en davantage sur les attributs de <router-link>.
à
Représente le lien vers la route cible. Lorsqu'il est cliqué, la valeur de `to` sera transmise à `router.push()` immédiatement, donc cette valeur peut être une chaîne ou un objet décrivant l'emplacement cible.
<!-- 字符串 -->
<router-link to="home">Home</router-link>
<!-- 渲染结果 -->
<a href="home.html">Home</a>
<!-- 使用 v-bind 的 JS 表达式 -->
<router-link v-bind:to="'home'">Home</router-link>
<!-- 不写 v-bind 也可以,就像绑定别的属性一样 -->
<router-link :to="'home'">Home</router-link>
<!-- 同上 -->
<router-link :to="{ path: 'home' }">Home</router-link>
<!-- 命名的路由 -->
<router-link :to="{ name: 'user', params: { userId: 123 }}">User</router-link>
<!-- 带查询参数,下面的结果为 /register?plan=private -->
<router-link :to="{ path: 'register', query: { plan: 'private' }}">Register</router-link>
remplacement
Si l'attribut replace est défini, un clic appellera router.replace() au lieu de router.push(), et aucun enregistrement d'historique ne sera laissé après la navigation.
<router-link :to="{ path: '/abc'}" replace></router-link>
append
Lorsque l'attribut append est défini, le chemin est préfixé au chemin actuel (relatif). Par exemple, si nous naviguons de /a vers un chemin relatif b, sans append le chemin est /b, avec append il est /a/b.
<router-link :to="{ path: 'relative/path'}" append></router-link>
balise
Parfois, vous voulez<router-link>pour effectuer le rendu sous forme d'une certaine balise, par exemple<li>.tagNous utilisons donc
<router-link to="/foo" tag="li">foo</router-link> <!-- 渲染结果 --> <li>foo</li>
active-class
la prop pour spécifier quelle balise. Il écoute toujours les clics et déclenche la navigation.
<style>
._active{
background-color : red;
}
</style>
<p>
<router-link v-bind:to = "{ path: '/route1'}" active-class = "_active">Router Link 1</router-link>
<router-link v-bind:to = "{ path: '/route2'}" tag = "span">Router Link 2</router-link>
</p>
Définissez le nom de classe CSS utilisé lorsque le lien est actif. Il peut être remplacé par le code suivant.classRemarque iciactive-class="_active"。
exact-active-class
use
<p>
<router-link v-bind:to = "{ path: '/route1'}" exact-active-class = "_active">Router Link 1</router-link>
<router-link v-bind:to = "{ path: '/route2'}" tag = "span">Router Link 2</router-link>
</p>
event
Configurez la classe qui doit être active lorsque le lien correspond exactement. Elle peut être remplacée par le code suivant.
<router-link v-bind:to = "{ path: '/route1'}" event = "mouseover">Router Link 1</router-link>
Le code ci-dessus définit l'événement sur mouseover, et lorsque la souris passe sur Router Link 1, le contenu HTML de destination changera.
Manuel de l'API principale de Vue Router (v4, Vue 3)
I.createRouterOptions de configuration
| Élément de configuration | Objectif | Exemple |
|---|---|---|
history |
Spécifier le mode d'URL | createWebHistory() |
routes |
Tableau de définition de la table de routage | [{ path: '/', component: Home }] |
scrollBehavior |
Contrôler la position de défilement de la page | { top: 0 } |
strict |
Indique s'il faut distinguer strictement les barres obliques finales | true |
linkActiveClass |
Classe lorsque le lien est actif | 'active' |
linkExactActiveClass |
Classe lorsque le lien est exactement actif | 'exact-active' |
parseQuery |
Analyse personnalisée des paramètres de requête d'URL | (q) => ({...}) |
stringifyQuery |
Sérialisation personnalisée des paramètres de requête d'URL | (obj) => 'a=1' |
II. Fabrique d'historique
| API | Objectif | Exemple |
|---|---|---|
createWebHistory() |
Utiliser le mode History HTML5 (recommandé) | createWebHistory() |
createWebHashHistory() |
Utiliser le mode Hash (l'URL contient#) |
createWebHashHistory() |
createMemoryHistory() |
Adapté au SSR (rendu côté serveur) | createMemoryHistory() |
III.RouteRecord(Enregistrement de route)
| Champ | Objectif | Exemple |
|---|---|---|
path |
Définition du chemin de route | /user/:id |
name |
Nommage de route | name: 'User' |
component |
Composant principal correspondant | UserView |
components |
Pour les vues nommées (multiples<router-view>) |
{ default: A, left: B } |
redirect |
Cible de redirection | redirect: '/login' |
children |
Définir des routes enfants imbriquées | [ { path: 'profile' } ] |
props |
vaparamsConvertir automatiquement en composantprops |
props: true |
meta |
Champ d'informations méta personnalisé | { auth: true } |
alias |
Ajouter des alias pour la route actuelle (plusieurs entrées) | alias: '/b' |
beforeEnter |
Garde de navigation spécifique à la route | { beforeEnter: (to,from,next)=>{} } |
IV. Navigation du routeur (méthodes de l'instance de routeur)
| API du routeur | Objectif | Exemple |
|---|---|---|
router.push(to) |
Navigation programmatique, ajoute un nouvel enregistrement à la pile d'historique | router.push('/a') |
router.replace(to) |
Navigation programmatique, remplace l'enregistrement d'historique actuel | router.replace('/a') |
router.back() |
Reculer d'une étape | router.back() |
router.forward() |
Avancer d'une étape | router.forward() |
router.go(n) |
Décaler manuellement la pile d'historique | router.go(-1) |
router.addRoute(route) |
Ajouter dynamiquement des enregistrements de route | router.addRoute({ name:'Post', ... }) |
router.removeRoute(name) |
Supprimer des enregistrements de route par nom | router.removeRoute('user') |
router.getRoutes() |
Obtenir tous les enregistrements de route | router.getRoutes() |
router.hasRoute(name) |
Déterminer si une route avec le nom spécifié existe | router.hasRoute('user') |
V. Gardiens de navigation
| Gardien | Portée | Signature du hook |
|---|---|---|
router.beforeEach |
Global avant | (to, from, next) => {} |
router.beforeResolve |
Phase de résolution globale (après résolution des gardes dans les composants et des composants asynchrones) | (to, from, next) => {} |
router.afterEach |
Global après (ne peut pas empêcher la navigation) | (to, from, failure) => {} |
beforeEnter |
Spécifique à la route | beforeEnter: (to, from, next) => {} |
beforeRouteEnter |
Dans le composant (ne peut pas accéderthis) |
beforeRouteEnter(to, from, next) {} |
beforeRouteUpdate |
Dans le composant (lorsque la route actuelle est réutilisée, par ex., modification de paramètre) | beforeRouteUpdate(to, from, next) {} |
beforeRouteLeave |
Dans le composant (lorsqu'on quitte ce composant) | beforeRouteLeave(to, from, next) {} |
VI.<router-link>Props
| Props | Objectif | Exemple |
|---|---|---|
to |
Adresse de la route cible | to="/a"ou:to="{ name: 'user', params: { id: 1 } }" |
replace |
Utilisation pendant la navigationrouter.replace() |
<router-link replace> |
custom |
Rendu personnalisé, utilisé avec les slots | <router-link custom v-slot="{ href }"> |
active-class |
Classe appliquée lorsque le lien est actif | 'active' |
exact-active-class |
Classe appliquée lorsque le lien correspond exactement | 'exact' |
VII.<router-view>Props
| Props | Objectif | Exemple |
|---|---|---|
name |
Utilisé pour le rendu multi-vues (vues nommées) | <router-view name="left"> |
route |
(Avancé) Spécifier explicitement l'objet de route à rendre | <router-view :route="someRoute"> |
VIII.Route(Objet de route actuel)
Cet objet est obtenu viauseRoute()outhis.$routeobtenues.
| Champ | Type | Signification | Exemple |
|---|---|---|---|
params |
object |
Paramètres de chemin dynamiques | route.params.id |
query |
object |
Paramètres de requête URL | route.query.q |
hash |
string |
Valeur de hachage dans l'URL (avec#) |
route.hash |
fullPath |
string |
Chemin résolu complet (y compris la requête et le hachage) | /user/1?x=1 |
name |
string |
Nom de la route actuelle | 'User' |
path |
string |
Chemin actuel (sans query ni hash) | /user/1 |
meta |
object |
Dans la configuration de la routemetainformation |
route.meta.auth |
matched |
RouteRecord[] |
Tous les enregistrements correspondant à la route (pour les routes imbriquées) | route.matched |
IX. Composition API
| API | Objectif | Exemple |
|---|---|---|
useRoute() |
Obtenir l'objet de route actuel (Route) |
const route = useRoute() |
useRouter() |
Obtenir l'instance du routeur (Router) |
const router = useRouter() |
X. Navigation programmatique (Exemple complet)
| Objectif | Exemple | Remarques |
|---|---|---|
| Navigation par route nommée | router.push({ name:'User', params:{ id:10 } }) |
Méthode recommandée, ne dépend pas de l'ordre des chemins |
| Navigation avec paramètres de requête | router.push({ path:'/search', query:{ q:'x' } }) |
Chemin + paramètres de requête |
| push/replace pouvant être attendu | await router.push('/a') |
La navigation est asynchrone, vous pouvez attendre sa fin |
| Navigation par objet URL | router.push({ path: '/foo', hash: '#bar' }) |
Contrôle total sur les détails de l'URL |