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 à unpage404.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

<div id="app"> <h1>Bonjour App !</h1> <p> <!--Utilisez le composant router-link pour la navigation--> <!--Spécifiez le lien en passant `to`--> <!--`<router-link>` affichera une balise `<a>` avec l'attribut `href` correct--> <router-link to="/">Aller à l'accueil</router-link> <router-link to="/about">Aller à la page À propos</router-link> </p> <!--Router View--> <!--Le composant correspondant à la route sera rendu ici.--> <router-view></router-view> </div>

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

//1. Définir les composants de route. //Ils peuvent également être importés depuis d'autres fichiers. const Home = { template: '<div>Home</div>' } const About = { template: '<div>About</div>' } //2. Définir quelques routes //Chaque route doit être associée à un composant. //Nous aborderons les routes imbriquées plus tard. const routes = [ { path: '/', component: Home }, { path: '/about', component: About }, ] //3. Créez l'instance du routeur et passez la configuration `routes` //Vous pouvez ajouter davantage de configuration ici, mais pour l'instant nous //restons simples pour le moment. const router = VueRouter.createRouter({ //4. En interne, une implémentation du mode history est fournie. Pour simplifier, nous utilisons ici le mode hash. history: VueRouter.createWebHashHistory(), routes, //Raccourci pour `routes: routes` }) //5. Créer et monter l'instance racine. const app = Vue.createApp({}) //Assurez-vous d'_utiliser_ l'instance du routeur afin que //toute l'application prend en charge le routage. app.use(router) app.mount('#app') //Maintenant, l'application a démarré !

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 { createApp } from 'vue';
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

import { createRouter, createWebHistory } from 'vue-router';

// 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

<template>
  <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
Autres extensions