Skip to content

5. Enrutamiento

Una aplicación tiene varias pantallas. En la web, cada pantalla tiene una dirección (/ex17/doctors/2): se puede referenciar, abrir mediante un enlace, recargar o proteger con guardias. [Angular] administra estas direcciones mediante su enrutador (el paquete [@angular/router]), que hemos venido usando desde el primer ejemplo: la página de inicio de la aplicación de ejemplos asocia la dirección /ex01 con la página del ejemplo 01, /ex02 con la página del ejemplo 02, y así sucesivamente. [Ionic] no reemplaza este enrutador: se apoya en él y agrega las funcionalidades que se esperan de una aplicación móvil. Su componente [<ion-router-outlet>] organiza las páginas en una pila: una página nueva se apila sobre la anterior (con la animación de Android), el botón Atrás del teléfono la quita de la pila y la página anterior, que permanece en memoria, reaparece exactamente como se dejó. Combina el [Navigator] de [Flutter] y el paquete [go_router].

5.1. Ejemplo 17: el enrutador

El ejemplo 17 tiene seis páginas: una página de inicio, una lista de médicos, el perfil de un médico, una página de búsqueda, una página “About” cargada bajo demanda y una página para direcciones desconocidas. Las cinco primeras se agrupan en un “shell”, con una barra de pestañas en la parte inferior de la pantalla (cuatro pestañas: la página de detalles de un médico pertenece a la pestaña Doctors).

5.1.1. Los datos

// =========================================================================
// src/app/ex17-router/data.ts - los datos del ejemplo 17
// -------------------------------------------------------------------------
// Datos "codificados de forma fija", 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' },
];

Datos “escritos en el código”, para no depender de un servidor en este ejemplo: una tabla de objetos descritos por la interfaz [Doctor].

5.1.2. Las rutas

// =========================================================================
// src/app/ex17-router/routes.ts - las RUTAS del ejemplo 17
// -------------------------------------------------------------------------
// Una aplicación tiene varias pantallas ("páginas"). El ENRUTADOR de Angular
// asocia una DIRECCIÓN (una ruta, como en la web: /ex17/doctors/2) con
// una página. Ionic se apoya en él: su <ion-router-outlet> lo convierte en una
// PILA de páginas (apilamos, desapilamos, el botón Atrás de Android desapila).
// Estas rutas son las HIJAS de la ruta /ex17 de app.routes.ts
// (loadChildren): sus rutas son relativas a /ex17.
//   'doctors/:id'    :id es un parámetro (/ex17/doctors/2 -> id = "2");
//   children         rutas mostradas DENTRO del "shell" (la barra
//                    superior, la barra de pestañas inferior);
//   redirectTo       una redirección: la dirección antigua lleva a la nueva;
//   '**'             el "comodín": cualquier dirección que ninguna ruta reconoce;
//   title            el título del documento (pestaña del navegador);
//   loadComponent    carga DIFERIDA: el código de la página solo se
//                    descarga en su primera visita.
// =========================================================================

import { ResolveFn, Routes } from '@angular/router';
import { Shell } from './shell';
import { doctors } from './data';
import { Home } from './pages/home.page';
import { DoctorDetail } from './pages/doctor-detail.page';
import { DoctorList } from './pages/doctor-list.page';
import { NotFoundPage } from './pages/not-found.page';
import { Search } from './pages/search.page';

// el título de la página de un médico, calculado a partir del parámetro :id de la dirección
const doctorTitle: ResolveFn<string> = (route) => {
  const doctor = doctors.find((m) => m.id === Number(route.paramMap.get('id')));
  return doctor ? `${doctor.firstName} ${doctor.lastName}` : 'Unknown doctor';
};

export const routes: Routes = [
  {
    // el shell (Shell) contiene la barra de pestañas; sus rutas hijas
    // se muestran DENTRO del shell, encima de la barra
    path: '',
    component: Shell,
    children: [
      // solo /ex17: vamos a la pestaña de inicio
      { path: '', redirectTo: 'home', pathMatch: 'full' },
      { path: 'home', title: 'Home', component: Home },
      { path: 'doctors', title: 'Doctors', component: DoctorList },
      // una página con un PARÁMETRO: /ex17/doctors/2; comienza con
      // 'doctors': pertenece a la pestaña Doctors, de la cual
      // apila una página sobre la lista
      { path: 'doctors/:id', title: doctorTitle, component: DoctorDetail },
      // /ex17/search?q=pediatrician: el parámetro q es un parámetro de CONSULTA (query)
      { path: 'search', title: 'Search', component: Search },
      // carga diferida: import() es una importación DINÁMICA
      // (una Promise); el código de la página se coloca en un archivo aparte
      {
        path: 'about',
        title: 'About',
        loadComponent: () => import('./pages/about.page').then((m) => m.About),
      },
      // una redirección: la ruta no tiene página, envía a otra dirección
      { path: 'physicians', redirectTo: 'doctors' },
    ],
  },
  // cualquier otra dirección bajo /ex17: la página de no encontrado, FUERA del shell
  { path: '**', title: 'Page not found', component: NotFoundPage },
];

Una ruta asocia una ruta de acceso con una página. Las rutas del ejemplo 17 se almacenan en su carpeta, y la ruta /ex17 de la aplicación las carga mediante [loadChildren] (se explica más adelante): son rutas hijas de /ex17, y sus rutas de acceso son relativas a /ex17 ([home] se refiere a la dirección /ex17/home).

  • Líneas 30–33: una función de tipo [ResolveFn<string>], que calcula el título de la página de un médico a partir del parámetro [:id] de la URL ([route.paramMap.get('id')]). La propiedad [title] de una ruta es el título del documento (la pestaña del navegador en la web): una cadena o una función de este tipo. Es el equivalente del widget [Title] de [Flutter];
  • Líneas 36–41: el shell del ejemplo. La ruta no tiene ruta de acceso propia ([path: '']); muestra el componente [Shell] (la barra superior y la barra de pestañas), y sus rutas hijas ([children]) se muestran EN el shell. Equivale a [ShellRoute] de [go_router];
  • línea 43: la dirección /ex17 sola se redirige a /ex17/home. [pathMatch: 'full']: la ruta se aplica solo si la dirección restante está vacía (de lo contrario, la ruta de acceso vacía, que es el comienzo de toda dirección, se aplicaría siempre);
  • líneas 44–45: una ruta estándar: su ruta de acceso, su título y su componente de página;
  • línea 49: una ruta con un parámetro: [doctors/:id], donde [:id] es un parámetro ([/ex17/doctors/2]: [id] equivale a ["2"], que siempre es una cadena). Con [go_router], esta ruta estaba anidada dentro de la de la lista; aquí es adyacente a ella. Su ruta de acceso comienza con [doctors]: para [Ionic], pertenece a la pestaña Doctors, y su página se apila sobre la lista, en la pila de esa pestaña;
  • línea 51: la búsqueda. Sus parámetros de consulta (después de [?]: [/ex17/search?q=pediatrician]) no aparecen en la ruta de acceso: cualquier ruta puede aceptarlos;
  • Líneas 54–58: carga diferida. [loadComponent] es una función que devuelve una [Promise]: [import('./pages/about.page')] es una importación dinámica de [JavaScript], que carga el archivo al ejecutarse, y [then] extrae de él el componente. La compilación ([ng build]) coloca entonces el código de la página en un archivo [JavaScript] aparte, que se descarga en la primera visita a la página. Es el equivalente de la importación de [Dart] con [deferred as];
  • línea 60: una redirección: la ruta no tiene página; redirige a otra dirección. [redirectTo] también puede ser una función que calcula la dirección;
  • línea 64: la ruta comodín [**] coincide con cualquier dirección que ninguna ruta anterior haya reconocido (el enrutador prueba las rutas en orden). Se coloca fuera del shell: la página “página no encontrada” tiene su propia barra de encabezado. Es el equivalente de [errorBuilder] de [go_router].

5.1.3. Inicio

El enrutador se configura una vez por todas, cuando se inicia la aplicación, en el archivo [main.ts]:

    // el enrutador: la lista de rutas (app.routes.ts);
    // withComponentInputBinding: los parámetros de una ruta se entregan a los
    // inputs (input) del componente de la página (vea el ejemplo 17)
    provideRouter(routes, withComponentInputBinding()),
  • línea 32: [provideRouter] recibe la lista de rutas de la aplicación; la opción [withComponentInputBinding()] proporciona los parámetros de una ruta (los de la ruta de acceso, como [:id], y los de la consulta, como [?q=]) a las entradas ([input()]) del mismo nombre en el componente de la página. Esto es lo que aquí reemplaza a [state.pathParameters['id']] con [go_router].

Y la ruta de la aplicación /ex17 (archivo [app.routes.ts]) carga las rutas del ejemplo:

  // los ejemplos 17 y 18 tienen sus propias rutas, "hijas" de /ex17 y /ex18
  { path: 'ex17', loadChildren: () => import('./ex17-router/routes').then((m) => m.routes) },
  { path: 'ex18', loadChildren: () => import('./ex18-guards/routes').then((m) => m.routes) },
  • línea 31: [loadChildren]: al igual que [loadComponent], una importación dinámica; el archivo del ejemplo [routes.ts], y todo lo que importa, se descarga solo la primera vez que se visita una URL que comienza con /ex17.

5.1.4. El shell de la aplicación

// =========================================================================
// src/app/ex17-router/shell.ts - el "shell" del ejemplo 17
// -------------------------------------------------------------------------
// La barra superior, la barra de pestañas inferior y, entre las dos, la página
// de la ruta actual. Es el componente <ion-tabs> de Ionic:
//   - <ion-tab-bar slot="bottom">: la barra de pestañas, en la parte inferior;
//   - <ion-tab-button tab="doctors">: una pestaña; al tocarla se va a
//     la dirección /ex17/doctors. La pestaña activa es aquella cuyo nombre es el
//     primer segmento de la dirección (después de /ex17): /ex17/doctors/2 -> Doctors;
//   - cada pestaña tiene su PROPIA pila de páginas: podemos entrar en el
//     detalle de un médico, cambiar a la pestaña Search, volver a la
//     pestaña Doctors... y encontrar de nuevo el detalle.
// =========================================================================

import { Component, computed, inject } from '@angular/core';
import { Router } from '@angular/router';
import {
  IonBackButton, IonButtons, IonHeader, IonIcon, IonLabel, IonTabBar, IonTabButton, IonTabs, IonTitle, IonToolbar,
} from '@ionic/angular';
import { addIcons } from 'ionicons';
import { home, informationCircle, people, search } from 'ionicons/icons';
import { DeferredLoading } from './pages/deferred-loading';

// las pestañas: el nombre de la pestaña (= la ruta, después de /ex17), la etiqueta, el ícono
const tabs = [
  { tab: 'home', label: 'Home', icon: 'home' },
  { tab: 'doctors', label: 'Doctors', icon: 'people' },
  { tab: 'search', label: 'Search', icon: 'search' },
  { tab: 'about', label: 'About', icon: 'information-circle' },
];

@Component({
  selector: 'app-ex17-shell',
  imports: [
    IonTabs, IonTabBar, IonTabButton, IonIcon, IonLabel, IonHeader, IonToolbar, IonButtons, IonBackButton, IonTitle,
    DeferredLoading,
  ],
  templateUrl: './shell.html',
  styles: `
    .address {
      background: var(--ion-color-light);
      color: var(--ion-color-light-contrast);
      padding: 8px;
      font-family: monospace;
      font-size: 12px;
    }
  `,
})
export class Shell {
  readonly tabs = tabs;
  private readonly router = inject(Router);

  // la dirección actual. lastSuccessfulNavigation es un SIGNAL del router:
  // la última navegación exitosa; finalUrl: su dirección, después de las
  // redirecciones. decodeURIComponent: %20 vuelve a ser un espacio
  readonly address = computed(() => {
    const navigation = this.router.lastSuccessfulNavigation();
    return navigation?.finalUrl ? decodeURIComponent(this.router.serializeUrl(navigation.finalUrl)) : '';
  });

  constructor() {
    // los íconos usados por la plantilla
    addIcons({ home, people, search, informationCircle });
  }
}
<!-- ======================================================================
     shell.html - el shell del ejemplo 17: <ion-tabs>
     ====================================================================== -->

<ion-tabs>
  <!-- slot="top": colocado ENCIMA de las páginas de las pestañas -->
  <ion-header slot="top">
    <ion-toolbar color="primary">
      <ion-buttons slot="start">
        <!-- este botón Atrás sale del ejemplo: desapila el shell -->
        <ion-back-button defaultHref="/" />
      </ion-buttons>
      <ion-title>Example 17 - the router</ion-title>
    </ion-toolbar>
    <div class="address">current address: {{ address() }}</div>
    <!-- una barra de progreso, mientras se carga una página diferida -->
    <app-deferred-loading />
  </ion-header>

  <!-- aquí, el propio <ion-tabs> coloca un <ion-router-outlet>: la página de
       la ruta hija actual -->

  <!-- la barra de pestañas, en la parte inferior: típica de una aplicación móvil -->
  <ion-tab-bar slot="bottom">
    @for (tab of tabs; track tab.tab) {
      <ion-tab-button [tab]="tab.tab">
        <ion-icon [name]="tab.icon" />
        <ion-label>{{ tab.label }}</ion-label>
      </ion-tab-button>
    }
  </ion-tab-bar>
</ion-tabs>

El shell es el componente [<ion-tabs>] de [Ionic]: una barra de pestañas y, encima de ella, la página de la pestaña seleccionada.

  • líneas 25–30 (shell.ts): las pestañas: un nombre (que también es la ruta de acceso después de /ex17), una etiqueta y un ícono;
  • líneas 56–59 (shell.ts): la dirección actual, un signal calculado ([computed]). El enrutador expone signals: [lastSuccessfulNavigation()], la última navegación exitosa, y [currentNavigation()], la navegación en curso (se explica más adelante). [finalUrl] es la dirección de destino, después de las redirecciones; [serializeUrl] la convierte en una cadena; [decodeURIComponent] decodifica los caracteres codificados ([%20] vuelve a ser un espacio). Como el signal se vuelve a leer con cada navegación, la dirección mostrada lo sigue;
  • línea 63 (shell.ts): los íconos que usa la plantilla;
  • líneas 7–18 (shell.html): la barra superior. [<ion-tabs>] coloca los elementos marcados con [slot="top"] encima de las páginas de las pestañas, y los demás debajo. El botón Atrás de esta barra cierra todo el shell: lo devuelve al menú de ejemplos;
  • línea 15 (shell.html): la dirección actual;
  • línea 17 (shell.html): una barra de progreso, que se muestra durante la navegación (véase más abajo);
  • líneas 20–21 (shell.html): [<ion-tabs>] coloca por sí mismo, entre las dos barras, un [<ion-router-outlet>]: la página de la ruta hija actual. Nosotros no escribimos esto;
  • líneas 24–31 (shell.html): la barra de pestañas inferior ([<ion-tab-bar slot="bottom">]), típica de una aplicación móvil, es el equivalente de [NavigationBar] de [Flutter]. Cada [<ion-tab-button [tab]="...">] es una pestaña; al tocarla se llega a la dirección /ex17/<tab name>.

Dos diferencias con [go_router]:

  • el código no calcula la pestaña activa: [<ion-tabs>] la deduce de la URL (la pestaña cuyo nombre es el primer segmento de la URL, después de /ex17: [/ex17/doctors/2] corresponde a la pestaña [doctors]);
  • Cada pestaña tiene su propia pila de páginas. Si ve los detalles de un médico, cambia a la pestaña Search y luego regresa a la pestaña Doctors, verá de nuevo los detalles del médico, y el botón Atrás lo lleva de vuelta a la lista. Este es el comportamiento estándar de las aplicaciones móviles (como las de [Android] y [iOS]).

5.1.5. Las páginas

Las páginas de las pestañas tienen solo un [<ion-content>]: su barra superior es la del shell.

// =========================================================================
// src/app/ex17-router/pages/home.page.ts - la pestaña de inicio
// -------------------------------------------------------------------------
// routerLink: un ENLACE a una dirección; un toque lleva allí, como un
// enlace <a href> en la web, pero sin recargar la aplicación.
// =========================================================================

import { Component } from '@angular/core';
import { RouterLink } from '@angular/router';
import { IonButton, IonContent } from '@ionic/angular';

@Component({
  selector: 'app-ex17-home',
  imports: [RouterLink, IonContent, IonButton],
  templateUrl: './home.page.html',
})
export class Home {}
<!-- ======================================================================
     home.page.html - la pestaña de inicio del ejemplo 17
     ====================================================================== -->

<!-- una página de pestaña solo tiene su contenido: la barra superior es la del shell -->
<ion-content class="ion-padding">
  <p>
    Welcome. Touch the tabs: the screen changes, and so does its address. On the web, the address
    is displayed in the browser's bar, the Back and Forward buttons work, as does
    reloading (F5) any page.
  </p>
  <!-- enlaces a direcciones particulares -->
  <ion-button fill="outline" routerLink="/ex17/physicians">/ex17/physicians (redirection)</ion-button>
  <ion-button fill="outline" routerLink="/ex17/unknown-page">Broken link</ion-button>
</ion-content>
  • líneas 13–14 (HTML): dos enlaces. La directiva [routerLink] de [Angular] (importada en la línea 9 del archivo .ts) convierte cualquier elemento en un enlace: al tocarlo se llega a la dirección especificada, igual que un enlace [<a href>] en la web, pero sin recargar la aplicación. El primero lleva a la redirección /ex17/physicians; el segundo, a una dirección que no existe.
// =========================================================================
// src/app/ex17-router/pages/doctor-list.page.ts - enlaces con un parámetro
// -------------------------------------------------------------------------
// [routerLink]="['/ex17/doctors', m.id]": la dirección se construye a partir de
// un array de segmentos: /ex17/doctors/2. La página del médico se
// APILA sobre la lista: el botón Atrás vuelve a ella.
// =========================================================================

import { Component } from '@angular/core';
import { RouterLink } from '@angular/router';
import { IonContent, IonItem, IonLabel, IonList } from '@ionic/angular';
import { doctors } from '../data';

@Component({
  selector: 'app-ex17-doctor-list',
  imports: [RouterLink, IonContent, IonList, IonItem, IonLabel],
  templateUrl: './doctor-list.page.html',
})
export class DoctorList {
  readonly doctors = doctors;
}
<!-- ======================================================================
     doctor-list.page.html - la pestaña Doctors del ejemplo 17
     ====================================================================== -->

<ion-content>
  <ion-list>
    @for (m of doctors; track m.id) {
      <!-- button: el elemento reacciona al toque; detail: la flecha > a la derecha -->
      <ion-item button detail [routerLink]="['/ex17/doctors', m.id]">
        <ion-label>{{ m.title }} {{ m.firstName }} {{ m.lastName }}</ion-label>
      </ion-item>
    }
  </ion-list>
</ion-content>
  • Línea 9 (HTML): un elemento de lista en el que se puede hacer clic ([button]), con una flecha a la derecha ([detail]). Su URL se construye a partir de un arreglo de segmentos: [[routerLink]="['/ex17/doctors', m.id]"] produce /ex17/doctors/2. La página del médico se APILA encima de la lista (una navegación “hacia adelante”): el botón Atrás regresa a esa página.
// =========================================================================
// src/app/ex17-router/pages/doctor-detail.page.ts - una página con un parámetro
// -------------------------------------------------------------------------
// El enrutador entrega el parámetro :id de la dirección al INPUT id de la página
// (input), una CADENA ("2"): eso es withComponentInputBinding() (main.ts).
// Si pasamos de /ex17/doctors/1 a /ex17/doctors/2, Angular conserva la
// misma página y solo cambia el valor del input: el médico mostrado,
// calculado (computed) a partir de él, lo sigue.
// Navegación por CÓDIGO: NavController, el servicio de navegación de Ionic.
// =========================================================================

import { Component, computed, inject, input } from '@angular/core';
import { IonButton, IonContent, IonRouterOutlet, IonText, NavController } from '@ionic/angular';
import { doctors } from '../data';

@Component({
  selector: 'app-ex17-doctor-detail',
  imports: [IonContent, IonButton, IonText],
  templateUrl: './doctor-detail.page.html',
})
export class DoctorDetail {
  // el parámetro :id de la dirección
  readonly id = input.required<string>();

  // Number("abc") es NaN: no se encontrará ningún médico (undefined)
  readonly doctor = computed(() => doctors.find((m) => m.id === Number(this.id())));
  // el número del siguiente médico: 1 -> 2 -> 3 -> 1
  readonly next = computed(() => ((this.doctor()?.id ?? 0) % doctors.length) + 1);

  private readonly navCtrl = inject(NavController);
  // la pila de páginas de la pestaña (el <ion-router-outlet> que muestra esta página)
  private readonly outlet = inject(IonRouterOutlet);

  back(): void {
    // canGoBack: ¿hay una página debajo? (no si llegamos
    // directamente a esta dirección, en la web)
    if (this.outlet.canGoBack()) {
      this.outlet.pop();
    } else {
      this.navCtrl.navigateBack('/ex17/doctors');
    }
  }

  nextDoctor(): void {
    // replaceUrl: la dirección REEMPLAZA a la dirección actual en el historial
    // (sin apilar: el botón Atrás lleva de vuelta a la lista)
    this.navCtrl.navigateForward(['/ex17/doctors', this.next()], { replaceUrl: true });
  }
}
<!-- ======================================================================
     doctor-detail.page.html - la página de un médico (ejemplo 17)
     ====================================================================== -->

<ion-content class="ion-padding">
  <!-- @if (...; as m): el valor de la prueba, llamado m, dentro del bloque -->
  @if (doctor(); as m) {
    <h2>{{ m.title }} {{ m.firstName }} {{ m.lastName }}</h2>
    <p>Specialty: {{ m.specialty }}</p>
    <ion-button fill="outline" (click)="back()">Back</ion-button>
    <ion-button (click)="nextDoctor()">Next doctor</ion-button>
  } @else {
    <ion-text color="danger">Doctor no. {{ id() }} does not exist.</ion-text>
  }
</ion-content>
  • línea 23 (.ts): la entrada [id], que recibe el parámetro [:id] de la dirección ([withComponentInputBinding]). [input.required<string>()]: una entrada obligatoria, de tipo cadena;
  • Línea 26 (.ts): el médico, un signal calculado a partir de la entrada. [Number("abc")] es igual a [NaN], que no es igual a ningún número: un [id] incorrecto produce [undefined] (antes era [int.tryParse] con [Dart]). Si se navega de /ex17/doctors/1 a /ex17/doctors/2, [Angular] conserva la misma página y solo cambia el valor de la entrada: el médico mostrado lo sigue;
  • línea 28 (.ts): el número del médico siguiente (1, 2, 3 y luego 1);
  • línea 30 (.ts): [NavController], el servicio de navegación de [Ionic]: navegación mediante CÓDIGO;
  • línea 32 (.ts): [IonRouterOutlet]: la pila de páginas que muestra esta página (la de la pestaña “Doctors”);
  • líneas 34–42 (.ts): el botón Atrás de la página. Si hay una página debajo de ella ([canGoBack()]), se quita de la pila ([pop()]); de lo contrario (en la web, el usuario puede haber llegado directamente a esta dirección), se lleva al usuario a la lista con una animación de “retroceso” ([navigateBack]);
  • líneas 44–48 (.ts): el médico siguiente: una navegación “hacia adelante” ([navigateForward]), pero con [replaceUrl: true]: la nueva dirección REEMPLAZA a la dirección actual en el historial. No hay pila: el botón Atrás regresa a la lista, no al médico anterior (esto era [context.pushReplacement] con [go_router]);
  • Líneas 7–14 (HTML): [@if (doctor(); as m)]: si el médico existe, se lo denomina [m] dentro del bloque; de lo contrario ([@else]), aparece un mensaje.

Con [Ionic], hay tres maneras de navegar:

  • mediante un enlace: [routerLink];
  • mediante el enrutador de [Angular]: [router.navigate([...])] o [router.navigateByUrl('...')];
  • mediante el [NavController] de [Ionic]: [navigateForward] (apilar una página era [context.push]), [navigateBack] (retroceder, desapilando las páginas superiores), [navigateRoot] (comenzar con una pila nueva; esto era [context.go]), [back()] (como el botón Atrás). Estos métodos llaman al enrutador de [Angular], especificando la DIRECCIÓN de la navegación, de la que dependen la animación y la administración de la pila.
// =========================================================================
// src/app/ex17-router/pages/search.page.ts - una página dirigida por la dirección
// -------------------------------------------------------------------------
// /ex17/search?q=pediatrician: la página queda totalmente descrita por su
// dirección. En la web, podemos guardarla como marcador, recargarla,
// retroceder. Buscar significa IR a la dirección /ex17/search?q=...:
// la página muestra lo que dice la dirección, y nada más.
// El parámetro de CONSULTA q (después del ?) también se entrega al input
// del mismo nombre (withComponentInputBinding); es undefined si no está.
// =========================================================================

import { Component, computed, inject, input } from '@angular/core';
import { Router } from '@angular/router';
import { IonContent, IonItem, IonLabel, IonList, IonSearchbar } from '@ionic/angular';
import { doctors } from '../data';

@Component({
  selector: 'app-ex17-search',
  imports: [IonContent, IonSearchbar, IonList, IonItem, IonLabel],
  templateUrl: './search.page.html',
})
export class Search {
  // el parámetro ?q=... de la dirección
  readonly q = input<string>();

  // los resultados: se recalculan cuando cambia la dirección (y por tanto q)
  readonly results = computed(() => {
    const text = (this.q() ?? '').toLowerCase();
    return doctors.filter((m) => `${m.firstName} ${m.lastName} ${m.specialty}`.toLowerCase().includes(text));
  });

  private readonly router = inject(Router);

  search(input: string): void {
    // queryParams: el enrutador construye la dirección, codificando lo
    // necesario (espacio -> %20)
    this.router.navigate(['/ex17/search'], { queryParams: { q: input.trim() } });
  }
}
<!-- ======================================================================
     search.page.html - la pestaña Search del ejemplo 17
     ====================================================================== -->

<ion-content class="ion-padding">
  <!-- un campo NO controlado: [value] le da el valor de la dirección (y
       se lo vuelve a dar si la dirección cambia: botón Atrás del navegador);
       #field: una referencia al componente, para leer su valor;
       enterkeyhint="search": la tecla Enter del teclado se convierte en una lupa -->
  <ion-searchbar
    #field
    placeholder="name or specialty"
    enterkeyhint="search"
    [value]="q() ?? ''"
    (keyup.enter)="search(field.value ?? '')"
  />
  <ion-list>
    @for (m of results(); track m.id) {
      <ion-item>
        <ion-label>{{ m.firstName }} {{ m.lastName }} ({{ m.specialty }})</ion-label>
      </ion-item>
    } @empty {
      <ion-item>
        <ion-label color="medium">No result.</ion-label>
      </ion-item>
    }
  </ion-list>
</ion-content>
  • Línea 24 (.ts): la entrada [q] recibe el parámetro de consulta [?q=...]. Puede faltar: en ese caso, la entrada es [undefined], lo que explica el tipo [input<string>()] (una cadena o [undefined]) y los valores [?? ''];
  • líneas 27–30 (.ts): los resultados, recalculados cuando cambia la dirección (es decir, [q]);
  • líneas 34–38 (.ts): la búsqueda: consiste en IR a la dirección /ex17/search?q=<input>. [router.navigate] recibe la ruta de acceso, y [queryParams] recibe los parámetros de consulta; construye la URL codificando las partes necesarias (un espacio se convierte en [%20]). La página queda completamente descrita por su dirección: en la web, se puede guardar como marcador, recargar o retroceder;
  • Líneas 10–16 (HTML): una barra de búsqueda de [Ionic] ([<ion-searchbar>], con su lupa y su botón de borrado). Es un campo NO controlado: [[value]] establece su valor a partir de la dirección y lo restablece si la dirección cambia (mediante el botón Atrás del navegador), igual que la clave [ValueKey(q)] en [Flutter]. [#field] es una variable de referencia de plantilla: se refiere al componente cuyo valor ([field.value]) se lee cuando se presiona la tecla Enter ([(keyup.enter)]). [enterkeyhint="search"]: la tecla Enter del teclado del teléfono se convierte en una lupa;
  • líneas 18–26 (html): los resultados; [@empty]: el contenido que se muestra cuando la lista está vacía.
// =========================================================================
// src/app/ex17-router/pages/about.page.ts - una página cargada bajo demanda
// -------------------------------------------------------------------------
// Vea loadComponent en routes.ts: el código de esta página se coloca, durante
// la compilación (ng build), en un archivo JavaScript aparte.
// =========================================================================

import { Component } from '@angular/core';
import { IonContent } from '@ionic/angular';

@Component({
  selector: 'app-ex17-about',
  imports: [IonContent],
  templateUrl: './about.page.html',
})
export class About {}
<!-- ======================================================================
     about.page.html - la pestaña About del ejemplo 17
     ====================================================================== -->

<ion-content class="ion-padding">
  <p>
    On the web, the code of this page was downloaded on the first visit (Network tab of the
    development tools: a chunk-XXXXXXXX.js file). On a phone, this file is
    already in the application: it is read on the spot, without download.
  </p>
</ion-content>

La página cargada bajo demanda (véase [loadComponent] en [routes.ts]) no tiene nada de especial: es la ruta la que determina la carga diferida. El resultado de [ng build] muestra su archivo aparte (“Lazy chunk files ... about-page”). Dicho sea de paso, en la aplicación de ejemplo todas las páginas se cargan de esta manera (véase [app.routes.ts]): al iniciar, solo se descarga el menú.

// =========================================================================
// src/app/ex17-router/pages/deferred-loading.ts
// -------------------------------------------------------------------------
// Una barra de progreso, mostrada mientras una navegación está EN CURSO:
// durante ese tiempo, el enrutador descarga el código de una página diferida
// (loadComponent), o espera la respuesta de un guard (ejemplo 18).
// currentNavigation es un SIGNAL del router: la navegación en curso, o
// null cuando no hay ninguna.
// =========================================================================

import { Component, inject } from '@angular/core';
import { Router } from '@angular/router';
import { IonProgressBar } from '@ionic/angular';

@Component({
  selector: 'app-deferred-loading',
  imports: [IonProgressBar],
  templateUrl: './deferred-loading.html',
})
export class DeferredLoading {
  readonly router = inject(Router);
}
1
2
3
4
5
6
7
<!-- ======================================================================
     deferred-loading.html - una barra de progreso "indeterminada"
     ====================================================================== -->

@if (router.currentNavigation()) {
  <ion-progress-bar type="indeterminate" />
}

Con [Flutter], el widget [DeferredLoading] mostraba un indicador de carga mientras se esperaba el código de la página. Con [Angular], el propio enrutador espera el código antes de mostrar la página: la página anterior permanece en pantalla durante ese tiempo. El componente [DeferredLoading] muestra, por lo tanto, una barra de progreso mientras la navegación está en curso:

  • línea 5 (html): [router.currentNavigation()] es un signal del enrutador: la navegación en curso, o [null]. Mientras se descarga una página diferida (o mientras se espera a un guardia, ejemplo 18), se muestra la barra de progreso ([<ion-progress-bar type="indeterminate">], una barra animada sin fin); al terminar la navegación, el signal vuelve a [null] y la barra desaparece. El shell la coloca debajo de su barra superior (línea 17 de shell.html).
// =========================================================================
// src/app/ex17-router/pages/not-found.page.ts - las direcciones desconocidas
// -------------------------------------------------------------------------
// La página de la ruta comodín '**' (routes.ts): está FUERA del
// shell, por lo que tiene su propia barra superior.
// =========================================================================

import { Component, computed, inject } from '@angular/core';
import { Router } from '@angular/router';
import { IonButton, IonContent, IonHeader, IonText, IonTitle, IonToolbar, NavController } from '@ionic/angular';

@Component({
  selector: 'app-ex17-not-found-page',
  imports: [IonHeader, IonToolbar, IonTitle, IonContent, IonText, IonButton],
  templateUrl: './not-found.page.html',
})
export class NotFoundPage {
  private readonly router = inject(Router);
  private readonly navCtrl = inject(NavController);

  // la dirección solicitada (vea shell.ts)
  readonly address = computed(() => {
    const navigation = this.router.lastSuccessfulNavigation();
    return navigation?.finalUrl ? decodeURIComponent(this.router.serializeUrl(navigation.finalUrl)) : '';
  });

  backHome(): void {
    // navigateBack: una navegación "hacia atrás" (la animación va de izquierda
    // a derecha); se desapila la página de no encontrado
    this.navCtrl.navigateBack('/ex17/home');
  }
}
<!-- ======================================================================
     not-found.page.html - la página de direcciones desconocidas (ejemplo 17)
     ====================================================================== -->

<ion-header>
  <ion-toolbar color="primary">
    <ion-title>Page not found</ion-title>
  </ion-toolbar>
</ion-header>

<ion-content class="ion-padding">
  <p><ion-text color="danger">No page at the address {{ address() }}.</ion-text></p>
  <ion-button (click)="backHome()">Back to home</ion-button>
</ion-content>

La página de direcciones desconocidas está fuera del shell: tiene su propia barra superior (líneas 5–9 del HTML). Muestra la dirección solicitada (líneas 22–25 del archivo .ts, como en el shell), y su botón lleva al usuario de vuelta a la página de inicio mediante una navegación de “retroceso” (línea 30 del archivo .ts): la página “página no encontrada” se desapila y reaparece el shell, que permanecía en memoria debajo.

5.1.6. Ejecución

La página de inicio; el perfil de un médico (apilado sobre la lista: la barra de pestañas sigue ahí, y el botón Atrás del teléfono regresa a la lista); los resultados de la búsqueda tras escribir “general practitioner” y presionar Enter; una dirección desconocida (el enlace roto de la página de inicio):

En un navegador ([ng serve]), la dirección también aparece en la barra de direcciones, los botones Atrás y Adelante funcionan, y se puede escribir una dirección manualmente: /ex17/doctors/3, /ex17/search?q=pediatrician, /ex17/physicians....

En comparación con [go_router], el enrutador de [Angular] es más declarativo: las rutas son una simple lista de objetos, los parámetros se pasan a los campos de entrada de la página y la carga diferida es simplemente una propiedad de la ruta. [Ionic] agrega funcionalidades propias de los dispositivos móviles: la pila de páginas ([<ion-router-outlet>]), las pestañas con pilas separadas ([<ion-tabs>]), la dirección de la navegación y las animaciones de navegación ([NavController]). Encontraremos exactamente los mismos conceptos en el cliente [Angular] de [RdvMedecins] (las rutas, [routerLink], [router.navigate]): solo los componentes de [Ionic] son específicos de los dispositivos móviles.

5.2. Ejemplo 18: restricciones de navegación

Algunas páginas solo deben ser abiertas por un usuario que haya iniciado sesión, o por un usuario con un rol específico. El enrutador de [Angular] las protege con guardias: funciones que llama antes de acceder a esas páginas.

5.2.1. La sesión

// =========================================================================
// src/app/ex18-guards/session.ts - una sesión SIMULADA (sin servidor)
// -------------------------------------------------------------------------
// El usuario que ha iniciado sesión debe ser conocido por las PÁGINAS (la barra superior,
// la agenda) y por los GUARDS del enrutador (funciones, que no son
// componentes). Lo almacenamos en un SERVICIO, un único objeto que todos
// obtienen con inject(Session) (vea el ejemplo 14):
//   - un signal privado, el estado;
//   - una vista de solo lectura de este signal;
//   - métodos para modificarlo.
// Quienes leen el signal (las plantillas) son notificados cuando cambia.
// (El ejemplo 23 hará lo mismo con un servidor real.)
// =========================================================================

import { Injectable, signal } from '@angular/core';

export type Role = 'ADMIN' | 'DOCTOR' | 'USER';

export interface User {
  login: string;
  role: Role;
}

// tres cuentas "codificadas de forma fija" (contraseña = login)
const accounts: Record<string, Role> = { admin: 'ADMIN', pelissier: 'DOCTOR', martin: 'USER' };

// providedIn: 'root': UNA sola instancia, para toda la aplicación
@Injectable({ providedIn: 'root' })
export class Session {
  // el estado: null, nadie ha iniciado sesión
  private readonly _user = signal<User | null>(null);
  // asReadonly: podemos leer el signal, no modificarlo
  readonly user = this._user.asReadonly();

  logIn(login: string, password: string): boolean {
    const role = accounts[login];
    if (role === undefined || password !== login) {
      return false;
    }
    this._user.set({ login, role });
    return true;
  }

  logOut(): void {
    this._user.set(null);
  }
}

Las páginas (la barra superior, la agenda) y los guardias del enrutador, que no son componentes, deben reconocer al usuario que inició sesión. Este se almacena en un servicio (véase el ejemplo 14), un objeto único que todos obtienen mediante [inject(Session)]:

  • líneas 17–22: los roles (un tipo “unión” formado por tres cadenas) y el usuario;
  • línea 25: tres cuentas “escritas en el código” (contraseña = nombre de usuario): un objeto que asocia un nombre de usuario con un rol ([Record<string, Role>]);
  • línea 28: [providedIn: 'root']: una única instancia del servicio para toda la aplicación;
  • líneas 31–33: el estado, un signal privado ([null]: nadie ha iniciado sesión) y su vista de solo lectura ([asReadonly()]): los demás pueden leerlo, pero solo los métodos del servicio pueden modificarlo;
  • líneas 35–42: la conexión, simulada. Modifica el signal: todo lo que lo lee (plantillas, signals calculados) lo sigue. Este es el [notifyListeners()] del [ChangeNotifier] de [Flutter], sin tener que escribirlo. (El ejemplo 23 hará lo mismo con un servidor real.)

5.2.2. Guardias y rutas protegidas

// =========================================================================
// src/app/ex18-guards/routes.ts - rutas PROTEGIDAS por guardias
// -------------------------------------------------------------------------
// canActivate: la lista de las GUARDIAS de una ruta, funciones (de tipo
// CanActivateFn) que el enrutador llama ANTES de ir allí. Una guardia recibe
// la ruta solicitada y el estado de la navegación (state.url: la dirección
// solicitada), y devuelve:
//   - true: la navegación continúa;
//   - false: se cancela;
//   - un UrlTree (una dirección construida por el enrutador): la navegación
//     se reemplaza por una navegación hacia esta dirección.
// Una guardia puede usar inject(): se la llama en un "contexto
// de inyección".
//
// Es el equivalente del lado del cliente de las guardias de NestJS (JwtAuthGuard,
// RolesGuard), con una diferencia FUNDAMENTAL: una guardia del cliente es
// solo una comodidad. La aplicación está en manos del usuario, que
// puede modificarla a voluntad. La protección real de los datos sigue siendo
// la del SERVIDOR (véase el capítulo sobre la caja negra).
// =========================================================================

import { inject } from '@angular/core';
import { CanActivateFn, Router, Routes } from '@angular/router';
import { Shell } from './shell';
import { Home } from './pages/home.page';
import { Schedule } from './pages/schedule.page';
import { Login } from './pages/login.page';
import { Role, Session } from './session';

// la guardia "login requerido": sin sesión iniciada -> a la página de inicio de sesión,
// recordando adónde se quería ir (parámetro returnUrl)
export const loginRequired: CanActivateFn = (route, state) => {
  if (inject(Session).user() === null) {
    return inject(Router).createUrlTree(['/ex18/login'], { queryParams: { returnUrl: state.url } });
  }
  return true;
};

// la guardia "rol requerido": una función que CONSTRUYE una guardia
export function roleRequired(...roles: Role[]): CanActivateFn {
  return (route, state) => {
    const u = inject(Session).user();
    if (u === null || !roles.includes(u.role)) {
      // con sesión iniciada, pero sin el rol adecuado: de vuelta al inicio, con un motivo
      return inject(Router).createUrlTree(['/ex18'], { queryParams: { denied: state.url } });
    }
    return true;
  };
}

export const routes: Routes = [
  {
    path: '',
    component: Shell,
    children: [
      { path: '', pathMatch: 'full', component: Home },
      { path: 'login', component: Login },
      { path: 'schedule', canActivate: [loginRequired], component: Schedule },
      {
        path: 'administration',
        // las guardias, en orden: gana la primera que no devuelve true
        canActivate: [loginRequired, roleRequired('ADMIN')],
        // el código de la página solo se carga una vez superadas las guardias
        loadComponent: () => import('./pages/administration.page').then((m) => m.Administration),
      },
      // cualquier otra dirección (ninguna ruta coincide): de vuelta al inicio
      { path: '**', redirectTo: '' },
    ],
  },
];

Un guardia de activación es una función de tipo [CanActivateFn], colocada en la lista [canActivate] de una ruta. El enrutador la llama antes de acceder a esa ruta; recibe la ruta solicitada y el estado de la navegación ([state.url]: la dirección solicitada), y devuelve:

  • [true]: la navegación continúa;
  • [false]: la navegación se cancela;
  • un [UrlTree], una dirección generada por el enrutador ([router.createUrlTree]): la navegación se reemplaza por una navegación a esa dirección.

Un guardia también puede devolver una [Promise] o un [Observable] con uno de estos valores (para consultar un servidor, por ejemplo). El código:

  • líneas 32–37: el guardia de “inicio de sesión requerido”: ¿no ha iniciado sesión? Redirige a la página de inicio de sesión, conservando el destino previsto (parámetro de consulta [returnUrl]). El guardia usa [inject()]: el enrutador lo llama en un “contexto de inyección”;
  • líneas 40–49: el guardia de “rol requerido” es CONSTRUIDO por una función, que recibe los roles permitidos ([...roles]: tantos parámetros como se desee, agrupados en un arreglo) y devuelve el guardia. ¿Inició sesión, pero sin el rol correcto? Se redirige a la página de inicio, con un motivo (parámetro [denied]);
  • líneas 52–55: el shell y sus rutas hijas, como en el Ejemplo 17;
  • línea 58: la página de la agenda requiere que el usuario haya iniciado sesión;
  • líneas 59–65: la administración requiere que el usuario haya iniciado sesión Y tenga el rol ADMIN. Los guardias de la lista se invocan en orden; el primero que no devuelve [true] gana (en este caso, era la cadena de [??] a [go_router]). El código de la página se carga ([loadComponent]) solo después de que se hayan superado los guardias;
  • línea 67: cualquier otra dirección bajo /ex18 redirige a la página de inicio.

Este es el equivalente en el cliente de las salvaguardas del servidor [NestJS] ([JwtAuthGuard], [RolesGuard]), con una diferencia FUNDAMENTAL: una salvaguarda del cliente es solo una comodidad (para evitar mostrar una pantalla innecesaria). La aplicación está en manos del usuario, quien puede modificarla a voluntad; la verdadera protección de los datos sigue estando en el servidor, que vuelve a verificar todo con cada solicitud (véase el capítulo sobre la caja negra).

Una diferencia con [go_router]: su opción [refreshListenable] reevaluaba los guardias de la página actual con cada cambio de sesión (se le redirigía a la página de inicio de sesión si cerraba sesión desde el calendario). El enrutador de [Angular] solo invoca los guardias al navegar. Por eso, después de cerrar sesión (como se describe más adelante) se navega a la página de inicio.

5.2.3. El shell y las páginas

// =========================================================================
// src/app/ex18-guards/shell.ts - los enlaces y el usuario conectado
// -------------------------------------------------------------------------
// La página del ejemplo 18: la barra superior (el usuario conectado), una
// barra de enlaces y, debajo, la página de la ruta hija actual, colocada
// por <router-outlet>. La plantilla LEE la señal de la sesión: por lo tanto
// sigue al usuario conectado.
// =========================================================================

import { Component, inject } from '@angular/core';
import { Router, RouterLink, RouterLinkActive, RouterOutlet } from '@angular/router';
import {
  IonBackButton, IonButton, IonButtons, IonChip, IonContent, IonHeader, IonIcon, IonTitle, IonToolbar,
} from '@ionic/angular';
import { addIcons } from 'ionicons';
import { logOutOutline } from 'ionicons/icons';
import { DeferredLoading } from '../ex17-router/pages/deferred-loading';
import { Session } from './session';

@Component({
  selector: 'app-ex18-shell',
  imports: [
    RouterOutlet, RouterLink, RouterLinkActive, IonHeader, IonToolbar, IonButtons, IonBackButton, IonTitle,
    IonButton, IonChip, IonIcon, IonContent, DeferredLoading,
  ],
  templateUrl: './shell.html',
  styles: `
    .links ion-button { text-transform: none; }
    .links .active { font-weight: bold; }
  `,
})
export class Shell {
  readonly session = inject(Session);
  private readonly router = inject(Router);

  constructor() {
    addIcons({ logOutOutline });
  }

  logOut(): void {
    this.session.logOut();
    this.router.navigateByUrl('/ex18');
  }
}
<!-- ======================================================================
     shell.html - el shell del ejemplo 18
     ====================================================================== -->

<ion-header>
  <ion-toolbar color="primary">
    <ion-buttons slot="start">
      <ion-back-button defaultHref="/" />
    </ion-buttons>
    <ion-title>Example 18 - guards</ion-title>
    <ion-buttons slot="end">
      <!-- @if (...; as u): el usuario conectado, llamado u dentro del bloque -->
      @if (session.user(); as u) {
        <ion-chip outline color="light">{{ u.login }} {{ u.role }}</ion-chip>
        <ion-button aria-label="logout" (click)="logOut()">
          <ion-icon slot="icon-only" name="log-out-outline" />
        </ion-button>
      } @else {
        <ion-button routerLink="/ex18/login">login</ion-button>
      }
    </ion-buttons>
  </ion-toolbar>
  <!-- los enlaces; routerLinkActive: la clase CSS "active" se aplica al
       enlace que designa la página mostrada; exact: toda la dirección debe
       coincidir (de lo contrario /ex18 estaría "active" en todas las páginas) -->
  <ion-toolbar class="links">
    <ion-button fill="clear" size="small" routerLink="/ex18" routerLinkActive="active"
      [routerLinkActiveOptions]="{ exact: true }">Home</ion-button>
    <ion-button fill="clear" size="small" routerLink="/ex18/schedule" routerLinkActive="active">
      Schedule (logged in)</ion-button>
    <ion-button fill="clear" size="small" routerLink="/ex18/administration" routerLinkActive="active">
      Administration (ADMIN)</ion-button>
  </ion-toolbar>
  <app-deferred-loading />
</ion-header>

<ion-content class="ion-padding">
  <!-- la página de la ruta hija actual -->
  <router-outlet />
</ion-content>
  • línea 17 (.ts): el shell reutiliza la barra de progreso del Ejemplo 17;
  • líneas 40–43 (.ts): cierre de sesión y luego página de inicio;
  • Líneas 11–21 (HTML): la barra superior lee el token de sesión; sigue al usuario que ha iniciado sesión (era [ListenableBuilder] con [Flutter]). Cuando se ha iniciado sesión, un [<ion-chip>] (un “chip”) muestra el login y el rol del usuario junto a un botón de cierre de sesión; de lo contrario, aparece un enlace a la página de inicio de sesión;
  • líneas 26–33 (HTML): una segunda barra con los enlaces. La directiva [routerLinkActive="active"] aplica la clase CSS [active] (en negrita, línea 29 del archivo .ts) al enlace que apunta a la página mostrada. Para la página de inicio, [[routerLinkActiveOptions]="{ exact: true }"] exige que coincida la URL completa: de lo contrario, dado que /ex18 es el comienzo de todas las URL del ejemplo, este enlace estaría siempre “activo”;
  • línea 39 (html): [<router-outlet>], el de [Angular]: la página de la ruta hija actual. Estas páginas son solo fragmentos del contenido del shell, sin la barra superior ni la animación: basta con el simple [<router-outlet>] de [Angular] dentro del [<ion-content>] del shell. El [<ion-router-outlet>] de [Ionic] está reservado para páginas completas, que se apilan.
// =========================================================================
// src/app/ex18-guards/pages/login.page.ts - la página de inicio de sesión
// -------------------------------------------------------------------------
// Tras iniciar sesión, se envía al usuario de vuelta a la página que quería
// abrir (parámetro ?returnUrl=... colocado allí por la guardia), o al inicio.
// =========================================================================

import { Component, inject, input, signal } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { Router } from '@angular/router';
import { IonButton, IonCard, IonCardContent, IonInput, IonText } from '@ionic/angular';
import { Session } from '../session';

@Component({
  selector: 'app-ex18-login',
  imports: [FormsModule, IonCard, IonCardContent, IonInput, IonButton, IonText],
  templateUrl: './login.page.html',
})
export class Login {
  // la dirección solicitada, colocada allí por la guardia loginRequired
  readonly returnUrl = input<string>();

  // los campos del formulario y el error: señales
  readonly login = signal('');
  readonly password = signal('');
  readonly error = signal(false);

  private readonly session = inject(Session);
  private readonly router = inject(Router);

  submit(): void {
    if (!this.session.logIn(this.login().trim(), this.password())) {
      this.error.set(true);
      return;
    }
    // solo se acepta una ruta INTERNA: empieza con /, pero no con //
    // (//site.com/... designa OTRO sitio): ninguna redirección hacia otro sitio
    const r = this.returnUrl();
    const internal = r !== undefined && r.startsWith('/') && !r.startsWith('//');
    this.router.navigateByUrl(internal ? r : '/ex18');
  }
}
<!-- ======================================================================
     login.page.html - el formulario de inicio de sesión (ejemplo 18)
     ====================================================================== -->

@if (returnUrl()) {
  <ion-card color="warning">
    <ion-card-content>Log in to open {{ returnUrl() }}.</ion-card-content>
  </ion-card>
}
<!-- [(ngModel)]="login": el campo y la señal login se mantienen iguales -->
<ion-input label="login" labelPlacement="floating" fill="outline" class="ion-margin-bottom" [(ngModel)]="login" />
<ion-input label="password" labelPlacement="floating" fill="outline" type="password"
  [(ngModel)]="password" (keyup.enter)="submit()" />
<ion-button class="ion-margin-top" (click)="submit()">Log in</ion-button>
@if (error()) {
  <p><ion-text color="danger">Incorrect login or password.</ion-text></p>
}
  • línea 21 (.ts): la dirección solicitada, introducida por el guardia en el parámetro [returnUrl];
  • líneas 24–26 (.ts): los campos del formulario y el error: signals;
  • líneas 31–41 (.ts): la conexión. Si falla, se devuelve un error; de lo contrario, se redirige al usuario a la página que quería abrir o a la página de inicio. Solo se acepta una ruta interna: empieza con [/], pero no con [//] ([//site.com/...] se refiere a OTRO sitio). En la web, una dirección de conexión generada por un tercero ([/ex18/login?returnUrl=//pirate-site.com]) nunca llevará, por lo tanto, a ningún otro lugar. [router.navigateByUrl] acepta una dirección completa, incluidos sus parámetros de consulta;
  • líneas 5–9 (HTML): el motivo de la conexión;
  • líneas 11–13 (html): [[(ngModel)]="login"] enlaza el campo con la signal [login] en ambos sentidos (véase el ejemplo 05); [(keyup.enter)] envía el formulario al presionar la tecla Enter.

Las demás páginas son muy sencillas:

// =========================================================================
// src/app/ex18-guards/pages/home.page.ts - la página pública
// -------------------------------------------------------------------------
// ?denied=...: colocado en la dirección por la guardia roleRequired cuando el rol
// no corresponde; el enrutador se lo entrega al input denied.
// =========================================================================

import { Component, input } from '@angular/core';
import { IonCard, IonCardContent } from '@ionic/angular';

@Component({
  selector: 'app-ex18-home',
  imports: [IonCard, IonCardContent],
  templateUrl: './home.page.html',
})
export class Home {
  readonly denied = input<string>();
}
<!-- ======================================================================
     home.page.html - la página pública del ejemplo 18
     ====================================================================== -->

@if (denied()) {
  <ion-card color="danger">
    <ion-card-content>Your role does not allow opening {{ denied() }}.</ion-card-content>
  </ion-card>
}
<p>Public page. Try the two other links, logged in or not (admin, pelissier, martin - password = login).</p>
// =========================================================================
// src/app/ex18-guards/pages/schedule.page.ts - una página reservada a los usuarios con sesión iniciada
// =========================================================================

import { Component, inject } from '@angular/core';
import { Session } from '../session';

@Component({
  selector: 'app-ex18-schedule',
  templateUrl: './schedule.page.html',
})
export class Schedule {
  readonly session = inject(Session);
}
1
2
3
4
5
<!-- ======================================================================
     schedule.page.html - la página de la agenda (ejemplo 18)
     ====================================================================== -->

<p>The schedule of <strong>{{ session.user()?.login }}</strong>: this page requires being logged in.</p>
// =========================================================================
// src/app/ex18-guards/pages/administration.page.ts - reservada al rol ADMIN
// -------------------------------------------------------------------------
// Cargada bajo demanda (loadComponent, en routes.ts): su código solo se
// descarga en la primera visita, y solo si las guardias lo permitieron.
// =========================================================================

import { Component } from '@angular/core';

@Component({
  selector: 'app-ex18-administration',
  templateUrl: './administration.page.html',
})
export class Administration {}
1
2
3
4
5
6
7
8
<!-- ======================================================================
     administration.page.html - la página de administración (ejemplo 18)
     ====================================================================== -->

<p>
  Administration: page reserved for the ADMIN role, loaded on demand (on the web, its code is only
  downloaded on the first visit, and only if the guards allowed it).
</p>

La página de inicio recibe el parámetro [denied] establecido por el guardia [roleRequired] (línea 17 del archivo .ts); la página de la agenda lee la sesión.

5.2.4. Ejecución

Sin haber iniciado sesión, solicitamos la interfaz de administración: el guardia nos redirige a la página de inicio de sesión (a la izquierda). Iniciamos sesión con la cuenta [martin] (rol USER): el inicio de sesión nos devuelve a la interfaz de administración, donde el segundo guardia deniega el acceso (en el centro). Cerramos sesión, solicitamos de nuevo la página de administración e iniciamos sesión con la cuenta [admin]: la página se abre (a la derecha):

Los guardias de [Angular] también existen en otras formas: [canMatch] (la ruta ni siquiera se reconoce si el guardia la rechaza: su código no se descarga), [canDeactivate] (salir de la página: “¿Descartar los cambios?”), [canActivateChild] (para todas las rutas hijas de una ruta). El cliente [Angular] de [RdvMedecins] los usa de la misma manera: un guardia del cliente solo orienta al usuario; es el servidor quien decide.