4. Enrutamiento
Una aplicación [Vue.js] carga una sola página HTML. Sin embargo, la aplicación [RdvMedecins] tiene una página de inicio de sesión, una página de agenda, una página “Mi espacio”... Cada una tiene su propia URL ([/login], [/schedule], [/my-area]), que se puede guardar como marcador, y los botones Atrás y Adelante del navegador funcionan. Este es el trabajo del enrutador, la biblioteca [vue-router].
4.1. Ejemplo 13: el enrutador
El enrutador se agrega a la aplicación en [main.ts]:
| // =========================================================================
// 13-router/src/main.ts
// -------------------------------------------------------------------------
// app.use(router): el enrutador se agrega a la aplicación. Los componentes
// <RouterLink> y <RouterView> pasan a ser utilizables en todas partes.
// =========================================================================
import { createApp } from 'vue';
import 'bootstrap/dist/css/bootstrap.min.css';
import App from './App.vue';
import { router } from './router';
createApp(App).use(router).mount('#app');
|
- Línea 13: [app.use(...)] instala una extensión ([plugin]): los componentes [<RouterLink>] y [<RouterView>], y las funciones [useRoute()] y [useRouter()], quedan disponibles en todas partes.
Los datos del ejemplo, “escritos directamente en el código”:
| // datos "fijos en el código", para no depender de un servidor en este ejemplo
export interface Doctor {
id: number;
title: string;
firstName: string;
lastName: string;
specialty: string;
}
export const DOCTORS: Doctor[] = [
{ id: 1, title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER', specialty: 'general practitioner' },
{ id: 2, title: 'Mr', firstName: 'Paul', lastName: 'TATOU', specialty: 'pediatrician' },
{ id: 3, title: 'Melle', firstName: 'Sophie', lastName: 'DUPONT', specialty: 'general practitioner' },
];
|
Las rutas:
| // =========================================================================
// 13-router/src/router.ts - las RUTAS de la aplicación
// -------------------------------------------------------------------------
// Una aplicación Vue.js es una aplicación de página única (SPA: Single
// Page Application): el navegador carga solo UNA página HTML. Cuando se hace clic en un
// enlace interno, no se envía ninguna solicitud al servidor:
// el enrutador cambia la dirección mostrada por el navegador, y reemplaza el
// componente mostrado en <RouterView>.
//
// Una ruta asocia una RUTA DE ACCESO (path) con un COMPONENTE (llamado "vista", en el
// sentido de una pantalla de la aplicación):
// '/doctors/:id' :id es un parámetro (/doctors/2 -> id = "2");
// '/:pathMatch(.*)*' cualquier ruta: la página "no encontrado"
// (la ruta más precisa siempre gana).
//
// createWebHashHistory: las direcciones se ven como /13-router/#/doctors/2.
// Todo lo que sigue al # se queda en el navegador: recargar la página (F5)
// siempre solicita de nuevo /13-router/, que existe. Es el modo más simple
// cuando el servidor no sabe nada del enrutador - aquí, el servidor de Vite, que
// sirve veinte ejemplos a la vez. El caso de estudio usará direcciones
// "limpias" (createWebHistory: /schedule, /doctors...).
// =========================================================================
import { createRouter, createWebHashHistory } from 'vue-router';
import Home from './views/Home.vue';
import DoctorList from './views/DoctorList.vue';
import DoctorDetail from './views/DoctorDetail.vue';
import Search from './views/Search.vue';
import NotFoundPage from './views/NotFoundPage.vue';
export const router = createRouter({
history: createWebHashHistory(),
routes: [
{ path: '/', name: 'home', component: Home },
{ path: '/doctors', name: 'doctors', component: DoctorList },
// props: true -> el parámetro :id se pasa al componente como una PROP
// (el componente deja entonces de depender del enrutador: más fácil de reutilizar)
{ path: '/doctors/:id', name: 'doctor', component: DoctorDetail, props: true },
{ path: '/search', name: 'search', component: Search },
// una redirección: la dirección antigua lleva a la nueva
{ path: '/physicians', redirect: '/doctors' },
{ path: '/:pathMatch(.*)*', name: 'not-found', component: NotFoundPage },
],
});
|
- Líneas 33–43: una ruta asocia una ruta de acceso con un componente, al que se llama “vista” (en el sentido de pantalla de una aplicación; esto no tiene nada que ver con las vistas de [Handlebars] del curso [NestJS], salvo por su función);
- línea 34: una ruta puede tener un nombre, que es más estable que su ruta de acceso para crear enlaces;
- Línea 38: [:id] es un parámetro: [/doctors/2] muestra [DoctorDetail] junto con [id = "2"]. La opción [props: true] lo pasa al componente como una prop: así, el componente ya no depende del enrutador;
- línea 41: una redirección: la dirección [/physicians] lleva a [/doctors];
- línea 42: una ruta comodín: la página “página no encontrada”. Solo recibe las direcciones que ninguna otra ruta reconoce: [vue-router] ordena las rutas según la precisión de su ruta de acceso; la más precisa tiene prioridad (aun así se coloca al final para mayor legibilidad);
- línea 32: el modo de historial. Con [createWebHashHistory], las direcciones adoptan la forma [/13-router/#/doctors/2]: lo que sigue a [#] nunca se envía al servidor, y al recargar la página (F5) siempre se solicita [/13-router/], que existe. Este es el enfoque más simple cuando el servidor no conoce las rutas del cliente, que es el caso del servidor de [Vite], que sirve veinte ejemplos a la vez. El caso de estudio usará [createWebHistory] y direcciones “limpias” ([/schedule]), lo que requiere un pequeño esfuerzo adicional por parte del servidor.
El “armazón” de la aplicación:
| <!--
=========================================================================
13-router/src/App.vue - el "cascarón" de la aplicación
-------------------------------------------------------------------------
- <RouterLink to="...">: un enlace interno. Produce una etiqueta <a>,
pero un clic no recarga la página: es el enrutador quien actúa.
El enlace de la página mostrada recibe la clase "router-link-active"
(aquí reemplazada por "active", la de Bootstrap);
- <RouterView />: el lugar donde se muestra el componente de la ruta
actual.
=========================================================================
-->
<script setup lang="ts">
import { RouterLink, RouterView, useRoute } from 'vue-router';
// useRoute(): la ruta actual (path, parámetros, query...), reactiva
const route = useRoute();
</script>
<template>
<div class="container py-4">
<h1 class="h3 mb-3">Example 13 - the router</h1>
<nav class="nav nav-pills mb-3">
<RouterLink class="nav-link" active-class="active" to="/">Home</RouterLink>
<!-- to puede ser un objeto: el NOMBRE de la ruta en lugar de su path -->
<RouterLink class="nav-link" active-class="active" :to="{ name: 'doctors' }">Doctors</RouterLink>
<RouterLink class="nav-link" active-class="active" :to="{ name: 'search', query: { q: 'general practitioner' } }">Search</RouterLink>
<RouterLink class="nav-link" to="/physicians">/physicians (redirection)</RouterLink>
<RouterLink class="nav-link" to="/unknown-page">Broken link</RouterLink>
</nav>
<p class="small text-muted">current route: <code>{{ route.fullPath }}</code> (name: {{ String(route.name) }})</p>
<div class="card p-3">
<RouterView />
</div>
</div>
</template>
|
- línea 17: la ruta actual (ruta de acceso, parámetros, [query]...), que es dinámica: la plantilla se actualiza cuando cambia;
- línea 24: [<RouterLink>] genera una etiqueta [<a>], pero al hacer clic no se recarga la página: el enrutador cambia la dirección y el componente mostrado. Al enlace de la página actual se le asigna la clase indicada por [active-class] (aquí, [active], que es la clase de [Bootstrap]);
- línea 26: el destino puede ser un objeto: el nombre de la ruta en lugar de su ruta de acceso;
- línea 27: un enlace con parámetros de consulta: [/search?q=general practitioner];
- línea 33: el lugar donde se muestra el componente de la ruta actual.
Las páginas. La lista de médicos genera enlaces con parámetros:
| <!-- 13-router/src/views/DoctorList.vue - enlaces con un parámetro -->
<script setup lang="ts">
import { RouterLink } from 'vue-router';
import { DOCTORS } from '../data';
</script>
<template>
<ul class="mb-0">
<li v-for="m in DOCTORS" :key="m.id">
<!-- { name, params }: el enrutador construye por sí mismo la dirección /doctors/2 -->
<RouterLink :to="{ name: 'doctor', params: { id: m.id } }">{{ m.title }} {{ m.firstName }} {{ m.lastName }}</RouterLink>
</li>
</ul>
</template>
|
- línea 11: el propio enrutador construye la dirección [/doctors/2] a partir del nombre de la ruta y de sus parámetros.
La página de un médico:
| <!--
13-router/src/views/DoctorDetail.vue - una página con un parámetro
El id llega como una PROP (props: true en router.ts), como cadena.
useRouter() da el propio enrutador, para navegar POR CÓDIGO.
-->
<script setup lang="ts">
import { computed } from 'vue';
import { useRouter } from 'vue-router';
import { DOCTORS } from '../data';
const props = defineProps<{ id: string }>();
const router = useRouter();
// computed: al pasar de /doctors/1 a /doctors/2, Vue REUTILIZA el
// mismo componente y solo cambia la prop - el computed lo sigue
const doctor = computed(() => DOCTORS.find((m) => m.id === Number(props.id)) ?? null);
const next = computed(() => (Number(props.id) % DOCTORS.length) + 1);
</script>
<template>
<div v-if="doctor">
<h2 class="h5">{{ doctor.title }} {{ doctor.firstName }} {{ doctor.lastName }}</h2>
<p>Specialty: {{ doctor.specialty }}</p>
<div class="d-flex gap-2">
<!-- navegación por código: router.push(...) o router.back() -->
<button class="btn btn-sm btn-outline-secondary" @click="router.back()">Back</button>
<button class="btn btn-sm btn-outline-primary" @click="router.push({ name: 'doctor', params: { id: next } })">Next doctor</button>
</div>
</div>
<p v-else class="text-danger mb-0">Doctor no. {{ id }} does not exist.</p>
</template>
|
- Línea 11: el parámetro [:id] se pasa como prop, en forma de cadena;
- línea 12: el propio enrutador, para navegar desde el código;
- línea 16: pasar de [/doctors/1] a [/doctors/2] no vuelve a crear el componente: [Vue.js] reutiliza el que está mostrado y solo cambia su prop. Un [computed] sigue este cambio; en cambio, el código colocado en [onMounted] se ejecutaría una sola vez;
- líneas 26 y 27: volver a la página anterior, ir a otra página.

La búsqueda es una página descrita íntegramente por su URL, igual que el formulario GET del curso [NestJS]:
| <!--
13-router/src/views/Search.vue - una página dirigida por el QUERY de la URL
(/search?q=pediatrician). Como con el formulario GET del curso de NestJS, la
página queda descrita por completo por su dirección: se puede
guardar en marcadores, recargar y navegar hacia atrás.
-->
<script setup lang="ts">
import { computed, ref, watch } from 'vue';
import { useRoute, useRouter } from 'vue-router';
import { DOCTORS } from '../data';
const route = useRoute();
const router = useRouter();
// el campo de entrada comienza con el valor de la URL...
const input = ref(String(route.query.q ?? ''));
// ... y sigue a la URL si esta cambia (botón Atrás, por ejemplo)
watch(() => route.query.q, (q) => (input.value = String(q ?? '')));
const results = computed(() => {
const q = String(route.query.q ?? '').toLowerCase();
return DOCTORS.filter((m) => `${m.firstName} ${m.lastName} ${m.specialty}`.toLowerCase().includes(q));
});
function search(): void {
// cambiamos la URL; la visualización sigue a la URL (computed de arriba)
router.push({ name: 'search', query: { q: input.value } });
}
</script>
<template>
<form class="d-flex gap-2 mb-3" @submit.prevent="search">
<input v-model="input" class="form-control" placeholder="name or specialty">
<button class="btn btn-primary">Search</button>
</form>
<ul class="mb-0">
<li v-for="m in results" :key="m.id">{{ m.firstName }} {{ m.lastName }} ({{ m.specialty }})</li>
</ul>
</template>
|
- línea 16: [route.query] contiene los parámetros de la URL ([?q=...]);
- línea 18: si la URL cambia (botón Anterior), el campo la sigue;
- línea 20: los resultados dependen de la URL, no del campo;
- línea 27: al buscar se cambia la URL; la visualización se actualiza en consecuencia. Se puede guardar la búsqueda como marcador, recargarla o retroceder.

4.2. Ejemplo 14: restricciones de navegación
Algunas páginas exigen haber iniciado sesión, mientras que otras requieren un rol específico. Este ejemplo simula un inicio de sesión sin servidor:
| // =========================================================================
// 14-guards/src/session.ts - una sesión SIMULADA (sin servidor)
// -------------------------------------------------------------------------
// El usuario conectado, en un ref declarado a nivel de MÓDULO: todos
// los archivos que importan este módulo comparten el mismo. (El ejemplo 15 hará
// lo mismo, mejor, con Pinia; el ejemplo 18 con un servidor real.)
// =========================================================================
import { ref } from 'vue';
export type Role = 'ADMIN' | 'DOCTOR' | 'USER';
export interface User {
login: string;
role: Role;
}
export const user = ref<User | null>(null);
// tres cuentas "fijas en el código" (contraseña = login)
const ACCOUNTS: Record<string, Role> = { admin: 'ADMIN', pelissier: 'DOCTOR', martin: 'USER' };
export function logIn(login: string, password: string): boolean {
const role = ACCOUNTS[login];
if (role === undefined || password !== login) {
return false;
}
user.value = { login, role };
return true;
}
export function logOut(): void {
user.value = null;
}
|
- Línea 18: un [ref] declarado en el nivel de módulo: todos los archivos que importan [session.ts] comparten el mismo;
Las rutas y sus guardias:
| // =========================================================================
// 14-guards/src/router.ts - rutas PROTEGIDAS
// -------------------------------------------------------------------------
// meta: información libre adjunta a una ruta. Aquí:
// - meta.requiresLogin: la página requiere haber iniciado sesión;
// - meta.roles : los roles autorizados (ausente = todos).
//
// router.beforeEach(...): una GUARDIA DE NAVEGACIÓN, ejecutada antes de CADA
// cambio de página. Devuelve:
// - true : la navegación continúa;
// - otra dirección : redirección;
// Es el equivalente en el cliente de los guardias de NestJS (JwtAuthGuard,
// RolesGuard) - con una diferencia FUNDAMENTAL: una guardia del cliente es
// solo una comodidad. El código del cliente está en manos del usuario, que
// puede modificarlo a voluntad. La protección real de los datos sigue siendo
// la del SERVIDOR (vea el capítulo sobre la caja negra).
// =========================================================================
import { createRouter, createWebHashHistory } from 'vue-router';
import { user, type Role } from './session';
import Home from './views/Home.vue';
import Login from './views/Login.vue';
import Schedule from './views/Schedule.vue';
// declaramos a TypeScript las propiedades meta que usamos
declare module 'vue-router' {
interface RouteMeta {
requiresLogin?: boolean;
roles?: Role[];
}
}
export const router = createRouter({
history: createWebHashHistory(),
routes: [
{ path: '/', component: Home },
{ path: '/login', component: Login },
{ path: '/schedule', component: Schedule, meta: { requiresLogin: true } },
{
path: '/administration',
// Carga DIFERIDA: el código de este componente solo se descarga
// en la primera visita de la página (Vite genera un archivo aparte para él)
component: () => import('./views/Administration.vue'),
meta: { requiresLogin: true, roles: ['ADMIN'] },
},
],
});
router.beforeEach((to) => {
if (to.meta.requiresLogin && user.value === null) {
// sin sesión iniciada: a la página de inicio de sesión, recordando adónde queríamos ir
return { path: '/login', query: { redirect: to.fullPath } };
}
if (to.meta.roles && user.value && !to.meta.roles.includes(user.value.role)) {
// con sesión iniciada, pero sin el rol adecuado: de vuelta a la página de inicio, con un motivo
return { path: '/', query: { denied: to.fullPath } };
}
return true;
});
|
- Líneas 26–31: declaramos en [TypeScript] las propiedades que almacenaremos en el campo [meta] de las rutas. [meta] acepta datos arbitrarios; declarar estas propiedades permite usarlas sin conversión de tipos;
- línea 38: la página requiere que el usuario haya iniciado sesión;
- línea 43: carga diferida: el código de este componente se descarga solo en la primera visita a la página. [Vite] lo almacena en un archivo aparte. De este modo, una aplicación carga al inicio solo lo que necesita;
- Líneas 49–59: una guardia de navegación, que se ejecuta antes de CADA cambio de página. Devuelve [true] para permitir el acceso, o bien otra dirección a la cual redirigir:
- sin sesión iniciada: redirige a [/login], conservando la página solicitada en el parámetro [redirect];
- con sesión iniciada pero sin el rol adecuado: vuelve a la página de inicio, con el motivo de la denegación.
La página de inicio de sesión redirige al usuario adonde quería ir:
| <!--
14-guards/src/views/Login.vue
Después de iniciar sesión, el usuario es enviado de vuelta a la página que quería
abrir (parámetro ?redirect=... establecido por el guard), o a la página de inicio.
-->
<script setup lang="ts">
import { ref } from 'vue';
import { useRoute, useRouter } from 'vue-router';
import { logIn } from '../session';
const route = useRoute();
const router = useRouter();
const login = ref('');
const password = ref('');
const error = ref(false);
function submit(): void {
error.value = !logIn(login.value.trim(), password.value);
if (!error.value) {
const redirect = route.query.redirect;
// solo se acepta una ruta INTERNA: comienza con /, pero no con //
// (//site.com/... designa OTRO sitio) - ninguna redirección a otro sitio
const internal = typeof redirect === 'string' && redirect.startsWith('/') && !redirect.startsWith('//');
router.push(internal ? redirect : '/');
}
}
</script>
<template>
<p v-if="route.query.redirect" class="alert alert-warning">Log in to open {{ route.query.redirect }}.</p>
<form class="d-flex flex-wrap gap-2" @submit.prevent="submit">
<input v-model="login" class="form-control w-auto" placeholder="login" autocomplete="username">
<input v-model="password" type="password" class="form-control w-auto" placeholder="password" autocomplete="current-password">
<button class="btn btn-primary">Log in</button>
</form>
<p v-if="error" class="text-danger mt-2 mb-0">Incorrect login or password.</p>
</template>
|
- Línea 23: solo se acepta una ruta INTERNA: comienza con [/], pero no con [//] ([//site.com/...] hace referencia a OTRO sitio). Redirigir a una URL completa recibida en la URL permitiría que un enlace malicioso envíe al usuario, inmediatamente después de iniciar sesión, a otro sitio que imite el nuestro (una vulnerabilidad conocida como [open redirect]).
Los demás archivos son muy cortos:
| <script setup lang="ts">
import { RouterLink, RouterView, useRouter } from 'vue-router';
import { logOut, user } from './session';
const router = useRouter();
function onLogOut(): void {
logOut();
router.push('/');
}
</script>
<template>
<div class="container py-4" style="max-width: 720px">
<h1 class="h3 mb-3">Example 14 - navigation guards</h1>
<nav class="d-flex gap-3 align-items-center mb-3">
<RouterLink to="/">Home</RouterLink>
<RouterLink to="/schedule">Schedule (logged in)</RouterLink>
<RouterLink to="/administration">Administration (ADMIN)</RouterLink>
<span class="ms-auto">
<template v-if="user">
{{ user.login }} <span class="badge text-bg-primary">{{ user.role }}</span>
<button class="btn btn-sm btn-link" @click="onLogOut">log out</button>
</template>
<RouterLink v-else to="/login">log in</RouterLink>
</span>
</nav>
<div class="card p-3"><RouterView /></div>
</div>
</template>
|
| <script setup lang="ts">
import { useRoute } from 'vue-router';
const route = useRoute();
</script>
<template>
<!-- ?denied=...: lo establece la guardia cuando el rol no corresponde -->
<p v-if="route.query.denied" class="alert alert-danger">Your role does not allow you to open {{ route.query.denied }}.</p>
<p class="mb-0">Public page. Try the two other links, logged in or not (admin, pelissier, martin - password = login).</p>
</template>
|
Al hacer clic en “Administración (ADMIN)” sin haber iniciado sesión, se llega a la página de inicio de sesión:

Con la sesión iniciada con la cuenta [martin] (rol [USER]), la guardia deniega el acceso a la página de administración:

Una nota FUNDAMENTAL: una guardia de navegación es solo una comodidad (para evitar mostrar una página innecesaria). El código del lado del cliente está en manos del usuario; puede leerlo y modificarlo en su navegador. La verdadera protección de los datos proviene del servidor, que verifica la identidad y el rol del usuario en cada solicitud. Lo veremos con el servidor [RdvMedecins].