2. Primeros pasos con Angular
2.1. Ejemplo 01: la estructura de una aplicación Angular
2.1.1. El archivo package.json
El archivo [package.json] de la carpeta de ejemplos declara las bibliotecas utilizadas y los comandos del proyecto:
| {
"name": "examples-angular",
"version": "1.0.0",
"description": "The small examples of the course [Step-by-step introduction to the Angular framework] - a single installation for all",
"private": true,
"scripts": {
"ng": "ng",
"start": "ng serve",
"build": "ng build"
},
"dependencies": {
"@angular/common": "^22.2.0",
"@angular/compiler": "^22.2.0",
"@angular/core": "^22.2.0",
"@angular/forms": "^22.2.0",
"@angular/platform-browser": "^22.2.0",
"@angular/router": "^22.2.0",
"@ngx-translate/core": "^18.0.0",
"bootstrap": "^5.3.8",
"rxjs": "~7.8.0",
"tslib": "^2.8.0"
},
"devDependencies": {
"@angular/build": "^22.2.0",
"@angular/cli": "^22.2.0",
"@angular/compiler-cli": "^22.2.0",
"typescript": "~6.0.2"
}
}
|
Analicemos este archivo:
- Líneas 6–10: los comandos del proyecto, que se lanzan con [npm run <name>] (o [npm start] para el comando [start]):
- [npm start 05-ngmodel] lanza [ng serve 05-ngmodel]: el servidor de desarrollo del ejemplo 05;
- [npm run build 05-ngmodel] lanza [ng build 05-ngmodel]: la versión de producción del ejemplo 05, ubicada en la carpeta [dist/05-ngmodel/];
- [npm run ng -- <arguments>] da acceso a todos los comandos de la herramienta [ng];
- Líneas 11–22: las bibliotecas necesarias para la aplicación en el navegador: los paquetes de [Angular] ([@angular/core], el núcleo; [@angular/common], herramientas comunes, incluido el cliente HTTP; [@angular/forms], formularios; [@angular/router], el enrutador; [@angular/platform-browser], inicialización en el navegador; [@angular/compiler], el compilador de plantillas; [ngx-translate] para los idiomas; [Bootstrap] para el formato, [RxJS] para los observables y [tslib], una pequeña biblioteca auxiliar utilizada por el código generado por [TypeScript];
- líneas 23–28: las herramientas de desarrollo: la herramienta de línea de comandos [ng] ([@angular/cli]), el compilador de [Angular] ([@angular/compiler-cli]), la herramienta de compilación ([@angular/build], que se apoya en [esbuild] y [Vite]) y el compilador de [TypeScript]. Estas no forman parte de la aplicación entregada a los usuarios.
El prefijo [^] en una versión ([^22.2.0]) permite a [npm] instalar una versión más reciente de la misma versión mayor (22.x.y); el prefijo [~] ([~6.0.2]) permite únicamente correcciones (6.0.x). Todos los paquetes [@angular/...] deben tener la misma versión.
En un proyecto estándar, este archivo lo crea el comando [ng new project-name], que genera una aplicación [Angular] completa y lista para ejecutarse. Los ejemplos de este curso se escribieron a mano para poder reunir veinticinco de ellos en una sola carpeta.
2.1.2. El archivo angular.json
[angular.json] describe el espacio de trabajo: las aplicaciones que contiene y cómo compilarlas y servirlas. Su comienzo, que describe el ejemplo 01:
| {
"$schema": "./node_modules/@angular/cli/lib/config/schema.json",
"version": 1,
"cli": {
"packageManager": "npm",
"analytics": false
},
"projects": {
"01-first-application": {
"projectType": "application",
"root": "01-first-application",
"sourceRoot": "01-first-application/src",
"prefix": "app",
"architect": {
"build": {
"builder": "@angular/build:application",
"options": {
"outputPath": "dist/01-first-application",
"index": "01-first-application/src/index.html",
"browser": "01-first-application/src/main.ts",
"tsConfig": "01-first-application/tsconfig.app.json",
"styles": [
"node_modules/bootstrap/dist/css/bootstrap.min.css"
]
},
"configurations": {
"production": {
"outputHashing": "all"
},
"development": {
"optimization": false,
"extractLicenses": false,
"sourceMap": true
}
},
"defaultConfiguration": "production"
},
"serve": {
"builder": "@angular/build:dev-server",
"options": {
"proxyConfig": "proxy.conf.json"
},
"configurations": {
"production": {
"buildTarget": "01-first-application:build:production"
},
"development": {
"buildTarget": "01-first-application:build:development"
}
},
"defaultConfiguration": "development"
}
}
},
|
- líneas 4–7: los ajustes de la herramienta [ng] (el administrador de paquetes, sin recopilación de estadísticas de uso);
- línea 9: el nombre del proyecto, el que se indica a [ng serve] o a [npm start];
- líneas 11–12: el directorio del proyecto y el directorio de código fuente;
- línea 13: el prefijo de los selectores de componentes ([app-root], [app-doctor-card]...);
- Líneas 15–37: la compilación de la aplicación ([ng build]):
- línea 16: la herramienta de compilación;
- línea 18: la carpeta de salida;
- líneas 19–20: la página HTML de la aplicación y su punto de entrada [TypeScript];
- línea 21: la configuración del proyecto [TypeScript];
- líneas 22–24: las hojas de estilo globales de la aplicación: aquí, la de [Bootstrap];
- líneas 26–36: dos configuraciones: [production] (código optimizado; [outputHashing] incluye un hash del contenido en el nombre de cada archivo) y [development] (código legible, con “source maps” que permiten depurar [TypeScript] en el navegador). [ng build] usa la primera de forma predeterminada (línea 36);
- líneas 38–52: el servidor de desarrollo ([ng serve]):
- línea 41: el archivo de proxy, que solo se usará a partir del ejemplo 22: cualquier solicitud del navegador a una dirección que comience con [/api] se reenvía al servidor JSON de [RdvMedecins]. Volveremos sobre esto;
- línea 51: [ng serve] compila la aplicación con la configuración [development].
Los otros veinticuatro ejemplos se describen de la misma manera más adelante en el archivo (más de mil líneas en total). Un proyecto estándar, creado con [ng new], contiene solo uno.
2.1.3. Los archivos tsconfig.json y tsconfig.app.json
La configuración de [TypeScript] común a todos los ejemplos:
| {
"compilerOptions": {
"strict": true,
"noImplicitOverride": true,
"noPropertyAccessFromIndexSignature": true,
"noImplicitReturns": true,
"noFallthroughCasesInSwitch": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"skipLibCheck": true,
"isolatedModules": true,
"experimentalDecorators": true,
"importHelpers": true,
"resolveJsonModule": true,
"target": "ES2022",
"module": "preserve"
},
"angularCompilerOptions": {
"strictInjectionParameters": true,
"strictInputAccessModifiers": true,
"strictTemplates": true
},
"include": ["*/src/**/*.ts", "common/**/*.ts"]
}
|
- línea 3: el modo estricto de [TypeScript] (tipos verificados rigurosamente, incluidos [null] y [undefined]);
- líneas 4–9: verificaciones adicionales; en particular, una variable o un parámetro sin usar se reporta como un error;
- línea 12: [Angular] usa los decoradores de [TypeScript] ([@Component], [@Injectable]...);
- línea 14: un archivo JSON se puede importar como un módulo (ejemplo 21);
- líneas 15–16: código [JavaScript] moderno (ES2022) y módulos procesados por la herramienta de compilación;
- líneas 18–22: verificaciones específicas del compilador de [Angular]. La más importante, en la línea 21: las plantillas se verifican como [TypeScript]. Un error tipográfico en una plantilla ([{{ titl }}] en lugar de [{{ title }}]) produce un error de compilación, reportado por [ng serve] y por el editor;
- línea 23: los archivos que muestra el editor ([VS Code]): los de todos los ejemplos.
Cada ejemplo tiene además su propio archivo, [tsconfig.app.json], que usa esta configuración y compila solo SUS archivos:
| {
"extends": "../tsconfig.json",
"include": ["src/**/*.ts"]
}
|
Así, un error en un ejemplo no impide que los demás funcionen.
2.1.4. La página index.html
Cada ejemplo tiene su propia página HTML. La del ejemplo 01:
| <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Example 01 - a first application</title>
<!-- base href: la dirección de inicio de las rutas relativas (ver el enrutador) -->
<base href="/">
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
<!-- la aplicación Angular se muestra en este elemento (ver src/main.ts) -->
<app-root></app-root>
</body>
</html>
|
Esta es la única página que cargará el navegador. Está casi vacía:
- línea 7: la dirección base para las rutas relativas de la página; el enrutador (ejemplo 17) la utiliza;
- línea 12: el elemento en el que [Angular] mostrará la aplicación. No es una etiqueta HTML conocida: es el selector del componente raíz de la aplicación.
No hay etiquetas [<script>] ni [<link>] : la herramienta de compilación las agrega automáticamente (el programa compilado, la hoja de estilo de [Bootstrap]).
2.1.5. El punto de entrada: main.ts
| // =========================================================================
// 01-first-application/src/main.ts - el punto de entrada de la aplicación
// -------------------------------------------------------------------------
// angular.json designa este archivo como punto de entrada ("browser"). Inicia
// la aplicación Angular a partir de su componente RAÍZ (App):
// Angular busca en index.html el elemento <app-root> (el "selector" de
// App) y muestra en él el HTML del componente.
// =========================================================================
import { bootstrapApplication } from '@angular/platform-browser';
import { App } from './app/app';
// bootstrapApplication(App) devuelve una promesa: mostramos en la consola del
// navegador un posible error de inicio
bootstrapApplication(App).catch((error) => console.error(error));
|
- Línea 10: la función de [Angular] que lanza una aplicación en un navegador;
- línea 11: el componente raíz de la aplicación, la clase [App] del archivo [app/app.ts];
- línea 15: la aplicación se lanza desde este componente: [Angular] busca en la página el elemento [<app-root>] y muestra allí el HTML de [App].
2.1.6. El componente raíz: app.ts, app.html, app.css
Un componente [Angular] es una clase [TypeScript] decorada con [@Component]:
| // =========================================================================
// 01-first-application/src/app/app.ts - un primer componente
// -------------------------------------------------------------------------
// Un componente Angular es una CLASE de TypeScript, decorada con @Component:
// - selector : la etiqueta HTML que lo representa (<app-root>);
// - templateUrl : el archivo de su HTML (app.html);
// - styleUrl : el archivo de su CSS (app.css), que solo se aplica
// a este componente.
// Las propiedades y los métodos de la clase se pueden usar en la plantilla.
// =========================================================================
import { Component, signal } from '@angular/core';
@Component({
selector: 'app-root',
templateUrl: './app.html',
styleUrl: './app.css',
})
export class App {
// datos "ordinarios": la plantilla puede mostrarlos
protected readonly title = 'Welcome to Angular';
protected readonly languages = ['TypeScript', 'HTML', 'CSS'];
// signal(...): un dato REACTIVO. Su valor se lee LLAMÁNDOLO
// (counter()) y se cambia con set() o update(). Angular actualiza entonces
// AUTOMÁTICAMENTE los lugares de la página que lo muestran.
protected readonly counter = signal(0);
protected readonly time = signal(new Date().toLocaleTimeString());
// un método llamado por el botón de la plantilla
protected increment(): void {
this.counter.update((n) => n + 1);
this.time.set(new Date().toLocaleTimeString());
}
}
|
- Líneas 14–18: el decorador [@Component] convierte la clase en un componente:
- línea 15: su selector, la etiqueta que lo representa en una plantilla o en [index.html];
- línea 16: su archivo de plantilla, HTML;
- línea 17: su archivo de estilo, CSS;
- líneas 21–22: dos datos ordinarios. [protected]: solo los usan el componente y su plantilla; [readonly]: no serán reemplazados;
- línea 27: [signal(0)] crea un dato reactivo con un valor inicial de 0. Una señal es una función: su valor se lee llamándola ([this.counter()]) y se cambia mediante [set(value)] o [update(function)]. Cuando cambia, [Angular] actualiza todos los lugares de la página que la muestran;
- líneas 31–34: un método que modifica dos señales. No altera la página: [Angular] la actualizará. [update((n) => n + 1)] calcula el nuevo valor a partir del anterior.
La plantilla del componente:
| <!-- 01-first-application/src/app/app.html - la plantilla del componente App -->
<div class="container py-4">
<!-- {{ expression }}: el valor de la expresión, insertado en la página -->
<h1 class="h3">{{ title }}</h1>
<p>This page is built in the browser, by Angular, from index.html, main.ts and the App component.</p>
<p>It is written in {{ languages.join(', ') }} ({{ languages.length }} languages).</p>
<!-- (click): el método que se llama al hacer clic (ver ejemplo 04) -->
<button class="btn btn-primary" (click)="increment()">Click me</button>
<!-- un signal se lee llamándolo: counter(), no counter -->
<p class="mt-3 counter">You clicked {{ counter() }} times (last click: {{ time() }}).</p>
</div>
|
- Línea 4: la sintaxis [{{ expression }}] (interpolación) inserta en la página el valor de una expresión [TypeScript], evaluada en el componente ([title] se refiere a [this.title]). Se escapa: si [title] contuviera [<b>], se mostraría [<b>] sin que la etiqueta se interprete;
- línea 6: la expresión puede ser cualquier cosa: una llamada a un método, un cálculo;
- línea 9: al hacer clic en el botón se llama al método [increment] (véase el ejemplo 04);
- línea 11: una señal se muestra llamándola como método: [{{ counter() }}]. [Angular] registra que la plantilla lee esta señal: cuando cambie, esta parte de la página se actualizará.
Y su estilo:
| /* esta regla solo se aplica a los elementos del componente App */
.counter {
font-weight: bold;
color: #dd0031;
}
|
Esta regla se aplica solo a los elementos de ESTE componente: [Angular] agrega un atributo único a sus elementos ([_ngcontent-xxx]) y lo transmite a los selectores CSS. Esto es la encapsulación de estilos: dos componentes pueden usar la misma clase CSS sin interferir entre sí.
Un componente también puede escribir su plantilla y su estilo directamente en el decorador, usando las propiedades [template] y [styles] en lugar de [templateUrl] y [styleUrl]. Los ejemplos siguientes lo mostrarán para componentes pequeños.
2.1.7. Ejecución
En la consola abierta en la carpeta [examples-angular]:
npm start 01-first-application
La consola muestra (extracto):
| Initial chunk files | Names | Raw size
styles.css | styles | 276.99 kB |
main.js | main | 4.91 kB |
Application bundle generation complete. [2.520 seconds]
Watch mode enabled. Watching for file changes...
➜ Local: http://localhost:4200/
|
Abra la URL http://localhost:4200/ y haga clic en el botón tres veces:

Dos experimentos para probar:
- Cambie el texto del título en [app.ts] y guarde el archivo: la página se actualiza de inmediato, sin necesidad de recargarla. El servidor de desarrollo vigila los archivos, recompila los cambios y avisa al navegador;
- vea el código fuente de la página (Ctrl-U): solo verá la página [index.html], que está casi vacía. La página HTML mostrada fue generada por [Angular] dentro del navegador. Para verla, use el inspector de las herramientas de desarrollo (F12, pestaña Elements) o la extensión [Angular DevTools], que además muestra los componentes y sus datos.
2.2. Ejemplo 02: señales
Las señales están en el centro de la reactividad de [Angular]. Este ejemplo calcula el precio con IVA de un artículo:
| // =========================================================================
// 02-signals/src/app/app.ts - signal, computed, effect, linkedSignal
// -------------------------------------------------------------------------
// Una pequeña calculadora de precios con IVA incluido:
// - signal : un valor reactivo, que se lee llamándolo y
// se modifica con set() / update();
// - computed : un valor CALCULADO a partir de otros signals,
// recalculado automáticamente cuando estos cambian;
// - effect : código ejecutado en cada cambio de los signals que
// lee (un "efecto secundario");
// - linkedSignal : un signal modificable, pero REINICIADO a un valor calculado
// cuando cambia otro signal.
// =========================================================================
import { Component, computed, effect, linkedSignal, signal, untracked } from '@angular/core';
// FormsModule aporta [(ngModel)], que enlaza un campo con un signal (ver ejemplo 05)
import { FormsModule } from '@angular/forms';
@Component({
selector: 'app-root',
imports: [FormsModule],
templateUrl: './app.html',
})
export class App {
protected readonly label = signal('Pen');
protected readonly priceExclVat = signal(2.5);
protected readonly vatRate = signal(20); // en %
// linkedSignal: la cantidad vuelve a 1 cada vez que cambia el artículo,
// pero el usuario puede modificarla mientras tanto
protected readonly quantity = linkedSignal({ source: this.label, computation: () => 1 });
// computed: nunca se asigna directamente, siempre se recalcula. Angular sabe
// de qué signals depende (los que LEE): lo recalcula cuando uno
// de ellos cambia, y solo en ese caso
protected readonly totalExclVat = computed(() => this.quantity() * this.priceExclVat());
protected readonly vatAmount = computed(() => (this.totalExclVat() * this.vatRate()) / 100);
protected readonly totalInclVat = computed(() => this.totalExclVat() + this.vatAmount());
// un formateador de montos en euros, estilo inglés (€1,234.50)
private readonly euros = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'EUR' });
// el historial de los totales con IVA incluido, llenado por el effect de abajo
protected readonly history = signal<string[]>([]);
private oldTotal: number | null = null;
constructor() {
// effect: se ejecuta una primera vez y luego en cada cambio de
// totalInclVat (el único signal que lee)
effect(() => {
const total = this.totalInclVat();
document.title = `Incl. VAT: ${this.format(total)}`;
if (this.oldTotal !== null) {
const line = `${this.format(this.oldTotal)} -> ${this.format(total)}`;
// untracked: modificar history SIN convertirlo en una dependencia del effect
untracked(() => this.history.update((h) => [line, ...h].slice(0, 5)));
}
this.oldTotal = total;
});
}
protected format(amount: number): string {
return this.euros.format(amount);
}
protected reset(): void {
this.label.set('Pen');
this.priceExclVat.set(2.5);
this.vatRate.set(20);
this.quantity.set(1);
}
}
|
- línea 15: las funciones de reactividad, todas proporcionadas por [@angular/core];
- Líneas 21 y 17: la plantilla usa [[(ngModel)]], que proviene del módulo [FormsModule]. Un componente debe importar (arreglo [imports]) todo lo que su plantilla utiliza: otros componentes, directivas y pipes. El compilador reporta un error si se omite;
- líneas 25–27: tres señales, [signal(initial value)]. Su tipo se infiere del valor inicial: [signal('Pen')] es una señal de cadena, [signal(2.5)] es una señal numérica;
- línea 31: una [linkedSignal] es una señal modificable (se puede escribir en ella, igual que en una señal ordinaria), pero está vinculada a otra señal, su origen: cada vez que el origen cambia (en este caso, la descripción del artículo), su valor se restablece al valor calculado por [computation] (en este caso, 1). Cuando el artículo cambia, la cantidad vuelve a 1;
- líneas 36–38: un [computed] es un valor calculado a partir de otras señales. Nunca se escribe; se lee como una señal ([this.totalExclVat()]). [Angular] sabe de qué señales depende, porque registra las que la función lee durante el cálculo. Se recalcula cuando una de ellas cambia, y solo en ese caso: leer [totalInclVat()] diez veces sin que nada cambie produce un único cálculo. Un [computed] puede depender de otros valores [computed] (línea 38);
- línea 41: un formateador de importes al estilo inglés (€1,234.50). El ejemplo 09 mostrará cómo hacerlo con [Angular], los pipes;
- líneas 50–59: un [effect] es una función que se ejecuta una vez y luego cada vez que cambian las señales que lee (aquí, la única [totalInclVat]). Se usa para efectos secundarios: realizar acciones sobre algo distinto de la página (el título de la pestaña, línea 52; el almacenamiento local del navegador; un registro);
- línea 56: el efecto agrega una entrada al historial. [untracked(...)] realiza esta actualización sin convertir a [history] en una dependencia del efecto; de lo contrario, el efecto leería [history] (en [update]) y se volvería a activar cada vez que cambie el historial... lo cual él mismo provoca;
- Un [effect] se crea en el constructor del componente (o al inicializar una propiedad): esto es lo que [Angular] llama el contexto de inyección, del que hablaremos más adelante al tratar los servicios (ejemplo 14). Se detiene por sí solo cuando el componente se destruye;
- Líneas 66–71: [set()] reemplaza el valor de una señal. La cantidad es una [linkedSignal]: se puede escribir en ella igual que en las demás.
Evite escribir en una señal mediante un [effect] cuando un [computed] es suficiente: un [computed] describe un valor, mientras que un [effect] describe una acción. Aquí, el historial depende de los valores sucesivos del total, algo que un [computed] no puede expresar.
La plantilla:
| <div class="container py-4">
<h1 class="h3 mb-3">Example 02 - signals</h1>
<div class="row g-4">
<div class="col-md-6">
<div class="card p-3">
<!-- [(ngModel)]="signal": el campo lee el signal y lo modifica (ver ejemplo 05) -->
<label class="form-label" for="label">Item</label>
<input id="label" class="form-control mb-2" [(ngModel)]="label">
<label class="form-label" for="price">Unit price excl. VAT</label>
<input id="price" type="number" step="0.1" min="0" class="form-control mb-2" [(ngModel)]="priceExclVat">
<label class="form-label" for="quantity">Quantity (back to 1 if the item changes)</label>
<input id="quantity" type="number" min="0" class="form-control mb-2" [(ngModel)]="quantity">
<label class="form-label" for="vat">VAT rate</label>
<select id="vat" class="form-select mb-3" [(ngModel)]="vatRate">
<!-- [ngValue]: el valor pasado es el NÚMERO 5.5, no la cadena "5.5" -->
<option [ngValue]="5.5">5.5 %</option>
<option [ngValue]="10">10 %</option>
<option [ngValue]="20">20 %</option>
</select>
<button class="btn btn-outline-secondary" (click)="reset()">Reset</button>
</div>
</div>
<div class="col-md-6">
<div class="card p-3">
<h2 class="h5">{{ quantity() }} x {{ label() }}</h2>
<table class="table mb-0">
<tbody>
<tr><td>Total excl. VAT</td><td class="text-end">{{ format(totalExclVat()) }}</td></tr>
<tr><td>VAT ({{ vatRate() }} %)</td><td class="text-end">{{ format(vatAmount()) }}</td></tr>
<tr class="fw-bold"><td>Total incl. VAT</td><td class="text-end">{{ format(totalInclVat()) }}</td></tr>
</tbody>
</table>
</div>
<div class="card p-3 mt-3">
<h2 class="h6">History of the total incl. VAT (effect)</h2>
<ul class="mb-0">
@for (line of history(); track $index) {
<li>{{ line }}</li>
}
</ul>
</div>
</div>
</div>
</div>
|
- líneas 8–18: [[(ngModel)]="label"] vincula el campo con la señal [label] en ambos sentidos: escribir en el campo cambia la señal, y cambiar la señal (con el botón “Reset”) cambia el campo. Se indica la señal misma, sin paréntesis: [ngModel] necesita la señal para poder escribir en ella. El ejemplo 05 tratará [ngModel] en detalle;
- líneas 10 y 12: con [type="number"], la señal recibe un número, no una cadena;
- líneas 16–18: [[ngValue]] proporciona el valor de una opción: en este caso, el número 5.5, no la cadena ["5.5"];
- líneas 25–30: la visualización de las señales y de [computed]. [format(...)] es un método del componente;
- líneas 37–39: [@for] repite el bloque para cada elemento de una lista (véase el ejemplo 03).
Con el servidor de desarrollo en ejecución ([npm start 02-signals]), modificamos el artículo, el precio, la cantidad y la tasa:

Cada vez que cambia el total con IVA, el efecto agrega una línea al historial y cambia el título de la pestaña. Al cambiar el artículo, la cantidad vuelve a 1.
Estas señales no son exclusivas de [Angular]: también existen en [SolidJS], [Preact], [Vue.js] (donde [ref] cumple la misma función), y una propuesta de estándar en borrador plantea incorporarlas al propio [JavaScript] . Antes de las señales (introducidas en [Angular] 16, en 2023), [Angular] verificaba periódicamente todo el árbol de componentes, mediante la biblioteca [zone.js], para determinar qué había cambiado. Con las señales, sabe exactamente qué actualizar: este es el modo “zoneless”, que es el predeterminado en [Angular] 22 y se usa en todos los ejemplos de este curso.
2.3. Ejemplo 03: sintaxis de plantillas
Una plantilla de [Angular] es HTML enriquecido con algunos elementos de sintaxis. Este ejemplo muestra una lista de médicos que se puede filtrar:
| // =========================================================================
// 03-templates/src/app/app.ts - la sintaxis de las plantillas
// -------------------------------------------------------------------------
// En una plantilla Angular:
// - [property]="expr" : una propiedad del elemento, calculada mediante una
// expresión ([src], [disabled], [hidden]...);
// - [class.name]="expr" : la clase CSS "name" si la expresión es verdadera;
// [style.prop]="expr" : una propiedad CSS;
// - @if / @else if / @else: un bloque que solo existe si la condición
// es verdadera;
// - @for (x of list; track x.id): un bloque repetido para cada elemento;
// track da la IDENTIDAD de cada elemento; @empty, el bloque que se muestra
// cuando la lista está vacía;
// - @switch / @case : un bloque entre varios, según un valor;
// - @let name = expr; : una variable local a la plantilla.
// =========================================================================
import { Component, computed, signal } from '@angular/core';
import { FormsModule } from '@angular/forms';
// una interfaz de TypeScript describe la forma de los objetos de la lista
interface Doctor {
id: number;
title: string;
firstName: string;
lastName: string;
specialty: 'general practitioner' | 'pediatrician' | 'cardiologist';
available: boolean;
}
@Component({
selector: 'app-root',
imports: [FormsModule],
templateUrl: './app.html',
})
export class App {
// la imagen está en la carpeta public/ del ejemplo: se sirve tal cual
protected readonly logoUrl = 'doctor.svg';
protected readonly doctors = signal<Doctor[]>([
{ id: 1, title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER', specialty: 'general practitioner', available: true },
{ id: 2, title: 'Mr', firstName: 'Paul', lastName: 'TATOU', specialty: 'pediatrician', available: false },
{ id: 3, title: 'Melle', firstName: 'Sophie', lastName: 'DUPONT', specialty: 'cardiologist', available: true },
]);
protected readonly filter = signal(''); // texto buscado
protected readonly onlyAvailable = signal(false);
protected readonly showHelp = signal(true);
// la lista mostrada: un computed, recalculado cuando cambia el filtro
protected readonly displayedDoctors = computed(() => {
const text = this.filter().trim().toLowerCase();
return this.doctors().filter(
(m) =>
(!this.onlyAvailable() || m.available) &&
`${m.firstName} ${m.lastName} ${m.specialty}`.toLowerCase().includes(text),
);
});
protected toggleHelp(): void {
this.showHelp.update((a) => !a);
}
}
|
- líneas 22–29: una interfaz [TypeScript] describe el formato de los objetos de la lista. La especialidad solo puede tomar tres valores (línea 27);
- línea 38: la dirección de una imagen. Los archivos de la carpeta [public/] del ejemplo se sirven tal cual, en la raíz del sitio: [doctor.svg] se refiere al archivo [03-templates/public/doctor.svg]. Para ello, debe declararse en [angular.json]:
| "assets": [
{
"glob": "**/*",
"input": "03-templates/public"
}
]
|
- líneas 40–44: [signal<Doctor[]>(...)]: una señal cuyo tipo se especifica, una lista de médicos;
- líneas 46–48: tres señales vinculadas a los campos de la página;
- líneas 51–58: la lista mostrada, un [computed] que depende de tres señales ([filter], [doctors], [onlyAvailable]);
- línea 61: [update] invierte un valor booleano.
La plantilla:
| <div class="container py-4">
<h1 class="h3 mb-3">
<!-- [src]: el valor de la propiedad src es el de logoUrl -->
<img [src]="logoUrl" alt="logo" width="32" height="32">
Example 03 - the template syntax
</h1>
<div class="d-flex flex-wrap gap-3 align-items-center mb-3">
<input class="form-control w-auto" placeholder="search..." [(ngModel)]="filter">
<label class="form-check-label">
<input type="checkbox" class="form-check-input" [(ngModel)]="onlyAvailable"> available only
</label>
<button class="btn btn-sm btn-outline-secondary" (click)="toggleHelp()">
{{ showHelp() ? "Hide the help" : "Show the help" }}
</button>
</div>
<!-- [hidden]: el párrafo permanece en la página, simplemente oculto -->
<p class="alert alert-info" [hidden]="!showHelp()">
Type a name or a specialty. Unavailable doctors are greyed out.
</p>
<!-- @let: una variable de plantilla, para no repetir la llamada -->
@let displayed = displayedDoctors();
<!-- @if / @else if / @else: solo uno de los tres bloques existe a la vez -->
@if (doctors().length === 0) {
<p class="text-muted">No doctor.</p>
} @else if (displayed.length === 0) {
<p class="text-warning">No doctor matches "{{ filter() }}".</p>
} @else {
<table class="table">
<thead>
<tr><th>#</th><th>Doctor</th><th>Specialty</th><th>Status</th></tr>
</thead>
<tbody>
<!-- @for: una fila por médico; $index da la posición.
track m.id: la identidad de cada fila, para que Angular sepa
qué fila agregar, mover o eliminar cuando cambia la lista -->
@for (m of displayed; track m.id; let i = $index) {
<tr [class.opacity-50]="!m.available">
<td>{{ i + 1 }}</td>
<td>{{ m.title }} {{ m.firstName }} {{ m.lastName }}</td>
<td>
<!-- @switch: un bloque según el valor de la especialidad -->
@switch (m.specialty) {
@case ('pediatrician') { <span title="children">🧸</span> }
@case ('cardiologist') { <span title="heart">❤️</span> }
@default { <span title="all patients">🩺</span> }
}
{{ m.specialty }}
</td>
<td>
<!-- [class] con una cadena: las clases calculadas se agregan a "badge" -->
<span class="badge" [class]="m.available ? 'text-bg-success' : 'text-bg-secondary'">
{{ m.available ? 'available' : 'unavailable' }}
</span>
</td>
</tr>
}
</tbody>
</table>
}
<!-- [style.font-size.px]: una propiedad CSS, con su unidad -->
<p [style.font-size.px]="12 + displayed.length * 2">
{{ displayed.length }} doctor(s) displayed - the size of this text depends on it.
</p>
</div>
|
- Línea 4: [[src]="logoUrl"] es un enlace de propiedad: a la propiedad [src] del elemento se le asigna el valor de la expresión [logoUrl]. Sin los corchetes, [src="logoUrl"] daría como resultado la cadena ["logoUrl"]. Cualquier propiedad de un elemento se puede enlazar de este modo: [[disabled]], [[value]], [[hidden]], [[title]]...;
- líneas 9 y 11: dos campos vinculados a señales mediante [[(ngModel)]] (véase el ejemplo 05);
- línea 14: la interpolación admite el operador ternario [? :];
- línea 19: [[hidden]]: el párrafo permanece en la página, pero simplemente está oculto (propiedad HTML [hidden]);
- línea 24: [@let] declara una variable de plantilla, visible en el resto de la plantilla. Esto evita tener que repetir [displayedDoctors()];
- líneas 27–63: [@if (condition) { ... } @else if (...) { ... } @else { ... }]: solo uno de los tres bloques existe en la página a la vez. A diferencia de [[hidden]], los elementos de un bloque que no se selecciona no se crean (o se eliminan);
- línea 40: [@for (m of displayed; track m.id)] repite el bloque para cada médico:
- [track m.id] es obligatorio: identifica cada fila. Cuando la lista cambia, [Angular] compara los identificadores para determinar qué fila agregar, mover o eliminar, en lugar de recrearlo todo. Para una lista de valores simples sin identificador, escriba [track $index] (ejemplo 02);
- [let i = $index]: el índice del elemento. [@for] también proporciona [$first], [$last], [$even], [$odd] y [$count];
- un bloque [@empty { ... }], que sigue al bloque [@for], aparece cuando la lista está vacía (ejemplo 16);
- línea 41: [[class.opacity-50]="condition"]: la clase [opacity-50] (de [Bootstrap]) se aplica al elemento si la condición es verdadera;
- líneas 46–50: [@switch] selecciona un bloque según un valor: un [@case] por valor, y [@default] para los demás;
- línea 55: [[class]="expression"]: la expresión devuelve una o más clases, que se agregan a las clases escritas directamente ([badge]);
- línea 66: [[style.font-size.px]="expression"]: una propiedad CSS, con su unidad.
Una expresión de plantilla se parece a [TypeScript], pero está restringida: no admite asignaciones (salvo en los manejadores de eventos, ejemplo 04), ni [new], ni acceso a variables globales ([window], [document]). Solo puede acceder a las propiedades y los métodos del componente.
[npm start 03-templates]:

Escriba “gen” y oculte la ayuda:

Las versiones anteriores de [Angular] escribían estos bloques mediante directivas estructurales: [*ngIf], [*ngFor], [[ngSwitch]]. Todavía se encuentran en muchos proyectos; hoy se recomienda la sintaxis [@if] / [@for] / [@switch], que se introdujo con [Angular] 17.
2.4. Ejemplo 04: eventos
Una lista de tareas que responde a las acciones del usuario. El componente:
| // =========================================================================
// 04-events/src/app/app.ts - reaccionar a las acciones del usuario
// -------------------------------------------------------------------------
// (event)="statement": la instrucción se ejecuta cuando el elemento
// emite este evento:
// - (click)="f()" llama a f;
// - (click)="f(3, $event)" llama a f con argumentos; $event es
// el evento nativo del navegador;
// - (keyup.enter), (keydown.escape): solo para esta tecla;
// - #name en un elemento: una "variable de referencia" de la plantilla, que
// designa el propio elemento HTML (name.value, name.focus()...).
// Aquí no hay FormsModule ni ngModel: leemos los campos nosotros mismos.
// =========================================================================
import { Component, signal } from '@angular/core';
interface Task {
id: number;
label: string;
done: boolean;
}
@Component({
selector: 'app-root',
templateUrl: './app.html',
styles: `
.area {
background: #e9f2ff;
height: 80px;
cursor: crosshair;
}
`,
})
export class App {
protected readonly tasks = signal<Task[]>([
{ id: 1, label: 'Install Node.js', done: true },
{ id: 2, label: 'Read the chapter on events', done: false },
]);
protected readonly log = signal<string[]>([]);
private nextId = 3;
private trace(message: string): void {
this.log.update((j) => [`${new Date().toLocaleTimeString()} ${message}`, ...j]);
}
// llamado por (submit): $event.preventDefault() evita que el navegador
// envíe el formulario al servidor (y que recargue la página)
protected add(event: SubmitEvent, field: HTMLInputElement): void {
event.preventDefault();
const label = field.value.trim();
if (label === '') {
return;
}
// un signal que contiene un arreglo: lo REEMPLAZAMOS por un nuevo arreglo
this.tasks.update((t) => [...t, { id: this.nextId++, label, done: false }]);
this.trace(`added "${label}"`);
field.value = '';
field.focus();
}
protected toggle(task: Task, done: boolean): void {
this.tasks.update((t) => t.map((x) => (x.id === task.id ? { ...x, done } : x)));
this.trace(`"${task.label}": ${done ? 'done' : 'to do'}`);
}
protected remove(task: Task): void {
this.tasks.update((t) => t.filter((x) => x.id !== task.id));
this.trace(`deleted "${task.label}"`);
}
// $event: el evento nativo (aquí un MouseEvent), con sus coordenadas
protected position(event: MouseEvent): void {
this.trace(`click at (${event.offsetX}, ${event.offsetY})`);
}
}
|
- líneas 26–32: el estilo del componente, escrito directamente en el decorador ([styles]), en lugar de en un archivo [.css];
- líneas 35–38: una señal que contiene una lista de objetos;
- línea 40: una propiedad ordinaria, que no se muestra: no necesita ser una señal;
- líneas 48–59: agregar una tarea. El método recibe el evento del navegador y el propio elemento [<input>] (véase la plantilla):
- línea 49: [preventDefault()] impide que el navegador envíe el formulario al servidor, lo que recargaría la página;
- línea 55: el arreglo contenido en la señal ([push]) no se modifica; en cambio, se reemplaza por un arreglo nuevo. Una señal solo notifica un cambio si su valor cambia, es decir, si se le asigna un objeto DISTINTO. Modificar el contenido del arreglo sin reemplazarlo dejaría la página sin cambios;
- líneas 57–58: el campo se vacía y conserva el foco;
- línea 62: el mismo principio para modificar una tarea: [map] crea un arreglo nuevo, en el que la tarea en cuestión se reemplaza por una copia modificada ([{ ...x, done }]);
- línea 67: y para eliminar una, [filter];
- Líneas 72–74: [MouseEvent]: el evento de clic, con la posición del puntero.
La plantilla:
| <div class="container py-4">
<h1 class="h3 mb-3">Example 04 - events</h1>
<!-- (submit): Enter en el campo O clic en el botón.
#newTask: una referencia al elemento <input>, utilizable en cualquier lugar
de la plantilla -->
<form class="d-flex gap-2 mb-3" (submit)="add($event, newTask)">
<input #newTask class="form-control" placeholder="new task (Escape to clear)"
(keydown.escape)="newTask.value = ''">
<button type="submit" class="btn btn-primary">Add</button>
</form>
<ul class="list-group mb-3">
@for (t of tasks(); track t.id) {
<li class="list-group-item d-flex align-items-center gap-2">
<!-- #box: la casilla de verificación de ESTA fila; box.checked: su estado -->
<input #box type="checkbox" class="form-check-input" [checked]="t.done"
(change)="toggle(t, box.checked)">
<span class="flex-grow-1" [class.text-decoration-line-through]="t.done" [class.text-muted]="t.done">
{{ t.label }}
</span>
<!-- un manejador con un argumento: la tarea de ESTA fila -->
<button class="btn btn-sm btn-outline-danger" (click)="remove(t)">Delete</button>
</li>
}
</ul>
<div class="area p-3 mb-3 rounded" (click)="position($event)">Click in this area</div>
<h2 class="h6">Log</h2>
<ul class="small">
@for (line of log(); track $index) {
<li>{{ line }}</li>
}
</ul>
</div>
|
- línea 7: [(submit)="instruction"] es un enlace de evento: la instrucción se ejecuta cuando el elemento dispara el evento [submit] (entrada en un campo o clic en un botón). [$event] se refiere al evento del navegador;
- Línea 8: [#newTask] es una variable de referencia de plantilla: se refiere al propio elemento [<input>], en toda la plantilla. En la línea 7, se pasa al método [add];
- Línea 9: [(keydown.escape)]: el evento [keydown], pero solo para la tecla Esc. De manera similar, se escribe [(keyup.enter)], [(keydown.control.s)]... En un enlace de evento se permite la asignación: [newTask.value = ''] vacía el campo;
- líneas 17–18: [#box] se refiere a la casilla de verificación de ESTA fila del [@for]; [[checked]] marca la casilla según la tarea; [(change)] notifica al componente cuando el usuario la cambia;
- Línea 23: un manejador con un argumento: la tarea de esta línea;
- línea 28: un clic en el campo: [$event] es un [MouseEvent].
Aquí, leemos los campos nosotros mismos ([field.value], [box.checked]). Los ejemplos siguientes delegarán esta tarea en [ngModel] y luego en los formularios basados en señales.
[npm start 04-events]; agregue una tarea (Enter), marque la segunda y haga clic en el campo:

[Angular] actualiza la página solo en respuesta a un evento o a un cambio de señal. Un evento gestionado por la plantilla ((click), (submit), etc.) basta para desencadenar una verificación del componente; sin embargo, los datos modificados posteriormente, fuera de un evento (por ejemplo, en respuesta a un servidor o cuando un temporizador se dispara), solo se mostrarán si son una señal. De ahí la regla seguida en todo este curso: todo dato mostrado por una plantilla es una señal.
El mismo formulario que el ejemplo 18 del curso [NestJS] (todos los tipos de campos), pero sin servidor: todo ocurre en el navegador. Los campos se vinculan a señales mediante la directiva [ngModel]:
| // =========================================================================
// 05-ngmodel/src/app/app.ts - todos los tipos de campo, enlazados con ngModel
// -------------------------------------------------------------------------
// [(ngModel)]="signal" (módulo FormsModule) enlaza un campo de formulario con un
// signal, en AMBOS sentidos: escribir en el campo modifica el signal, y
// modificar el signal (por código) modifica el campo. La sintaxis [( )], llamada
// "banana en una caja", combina [ngModel] (del signal al campo) y
// (ngModelChange) (del campo al signal). El valor recibido depende del campo:
// - text input, textarea -> string
// - input type="number" -> number (null si el campo está vacío)
// - single checkbox -> boolean
// - radio buttons -> el valor del botón elegido
// - select / multiple select -> el valor / un arreglo de valores
// - input type="date" -> string "yyyy-MM-dd"
// En un <form>, cada campo enlazado con ngModel debe tener un atributo name.
// Mismo formulario que el ejemplo 18 del curso de NestJS; pero aquí no hay
// servidor: todo ocurre en el navegador.
// =========================================================================
import { Component, computed, signal } from '@angular/core';
import { JsonPipe } from '@angular/common';
import { FormsModule } from '@angular/forms';
@Component({
selector: 'app-root',
// JsonPipe: el "pipe" json, que muestra un objeto en formato JSON (ver ejemplo 09)
imports: [FormsModule, JsonPipe],
templateUrl: './app.html',
})
export class App {
protected readonly titles = ['Mr', 'Mme', 'Melle'];
protected readonly possibleHobbies = ['sport', 'music', 'reading', 'cinema'];
protected readonly countries = [
{ code: 'fr', name: 'France' },
{ code: 'be', name: 'Belgium' },
{ code: 'ch', name: 'Switzerland' },
];
// un signal por campo del formulario
protected readonly title = signal('Mme');
protected readonly name = signal('');
protected readonly age = signal<number | null>(30);
protected readonly presentation = signal('');
protected readonly newsletter = signal(false);
protected readonly hobbies = signal<string[]>(['reading']);
protected readonly country = signal('fr');
protected readonly languages = signal<string[]>([]);
protected readonly birthDate = signal('');
// todos los valores, reunidos en un objeto (lo que se enviaría a un servidor)
protected readonly model = computed(() => ({
title: this.title(),
name: this.name().trim(), // ngModel no elimina los espacios: lo hacemos aquí
age: this.age(),
presentation: this.presentation(),
newsletter: this.newsletter(),
hobbies: this.hobbies(),
country: this.country(),
languages: this.languages(),
birthDate: this.birthDate(),
}));
protected readonly sent = signal<string | null>(null);
// varias casillas de verificación para UN arreglo: ngModel no puede hacerlo, lo manejamos nosotros
protected toggleHobby(hobby: string, checked: boolean): void {
this.hobbies.update((l) => (checked ? [...l, hobby] : l.filter((x) => x !== hobby)));
}
// (ngSubmit): el envío del formulario, sin recargar la página
protected send(): void {
this.sent.set(JSON.stringify(this.model()));
}
}
|
- Línea 22: [FormsModule] incluye la directiva [ngModel] (así como [ngSubmit], [ngModelOptions]...): son los llamados formularios “basados en plantillas” ([template-driven forms]);
- línea 27: el componente también importa el pipe [json], que muestra un objeto en formato JSON (véase el ejemplo 09);
- líneas 40–48: una señal por campo, con el tipo de valor que el campo proporcionará: una cadena, un número (o [null] si el campo está vacío), un booleano o una lista de cadenas;
- líneas 51–61: todos los valores, agrupados en un solo objeto mediante [computed]: esto es lo que se enviaría a un servidor. [ngModel] no elimina los espacios alrededor de una entrada: lo hacemos aquí (línea 53);
- líneas 66–68: varias casillas de verificación para la misma lista: [ngModel] no puede manejar esto, así que nos encargamos nosotros;
- líneas 71–73: el envío.
La plantilla:
| <div class="container py-4">
<h1 class="h3 mb-3">Example 05 - the fields of a form and ngModel</h1>
<div class="row g-4">
<!-- (ngSubmit): con FormsModule, el navegador nunca envía el formulario al
servidor; se llama a nuestro método en su lugar -->
<form class="col-md-7" (ngSubmit)="send()">
<div class="mb-3">
<span class="form-label d-block">Title</span>
<!-- botones de opción: el mismo ngModel, un valor por botón -->
@for (t of titles; track t) {
<div class="form-check form-check-inline">
<input type="radio" class="form-check-input" name="title" [id]="'title-' + t" [value]="t"
[(ngModel)]="title">
<label class="form-check-label" [for]="'title-' + t">{{ t }}</label>
</div>
}
</div>
<div class="row g-3 mb-3">
<div class="col-8">
<label class="form-label" for="name">Name</label>
<input id="name" name="name" class="form-control" [(ngModel)]="name">
</div>
<div class="col-4">
<label class="form-label" for="age">Age</label>
<!-- type="number": el signal recibe un número, no la cadena "30" -->
<input id="age" name="age" type="number" class="form-control" [(ngModel)]="age">
</div>
</div>
<div class="mb-3">
<label class="form-label" for="presentation">Presentation (updated when leaving the field)</label>
<!-- updateOn: 'blur': el signal solo se actualiza al salir del campo -->
<textarea id="presentation" name="presentation" rows="2" class="form-control"
[(ngModel)]="presentation" [ngModelOptions]="{ updateOn: 'blur' }"></textarea>
</div>
<div class="mb-3 form-check">
<!-- una sola casilla de verificación: true / false -->
<input id="newsletter" name="newsletter" type="checkbox" class="form-check-input" [(ngModel)]="newsletter">
<label for="newsletter" class="form-check-label">Receive the newsletter</label>
</div>
<div class="mb-3">
<span class="form-label d-block">Hobbies</span>
<!-- varias casillas de verificación para un arreglo: [checked] + (change) -->
@for (h of possibleHobbies; track h) {
<div class="form-check form-check-inline">
<input #hobbyBox type="checkbox" class="form-check-input" [id]="'hobby-' + h"
[checked]="hobbies().includes(h)" (change)="toggleHobby(h, hobbyBox.checked)">
<label class="form-check-label" [for]="'hobby-' + h">{{ h }}</label>
</div>
}
</div>
<div class="row g-3 mb-3">
<div class="col-6">
<label class="form-label" for="country">Country</label>
<select id="country" name="country" class="form-select" [(ngModel)]="country">
<!-- [value]: el valor pasado (el código), siendo el texto mostrado el nombre -->
@for (c of countries; track c.code) {
<option [value]="c.code">{{ c.name }}</option>
}
</select>
</div>
<div class="col-6">
<label class="form-label" for="languages">Spoken languages</label>
<select id="languages" name="languages" multiple size="3" class="form-select" [(ngModel)]="languages">
<option value="fr">French</option>
<option value="en">English</option>
<option value="es">Spanish</option>
</select>
</div>
</div>
<div class="mb-3">
<label class="form-label" for="birthDate">Date of birth</label>
<input id="birthDate" name="birthDate" type="date" class="form-control w-auto" [(ngModel)]="birthDate">
</div>
<button type="submit" class="btn btn-primary">Send</button>
</form>
<div class="col-md-5">
<h2 class="h6">The model, live</h2>
<pre class="bg-light p-2 rounded small">{{ model() | json }}</pre>
@if (sent(); as text) {
<h2 class="h6">Last submission</h2>
<pre class="bg-success-subtle p-2 rounded small">{{ text }}</pre>
}
</div>
</div>
</div>
|
- línea 6: [(ngSubmit)]: con [FormsModule], el navegador nunca envía el formulario (no hay recarga de la página); en su lugar se llama al método [send]. Ya no se necesita [preventDefault()] (véase el ejemplo 04);
- líneas 12–13: botones de opción: el mismo [ngModel] en cada botón, y un valor por botón ([[value]]). La señal recibe el valor del botón seleccionado;
- línea 21: [[(ngModel)]="name"] vincula el campo con la señal [name], en ambos sentidos. La sintaxis [[( )]], conocida como “banana en una caja”, combina un enlace de propiedad [[ngModel]] (de la señal al campo) y un enlace de evento [(ngModelChange)] (del campo a la señal). En un [<form>], cada campo vinculado mediante [ngModel] debe tener un atributo [name];
- línea 26: con [type="number"], la señal recibe un número;
- línea 33: [[ngModelOptions]="{ updateOn: 'blur' }"]: la señal se actualiza solo al salir del campo, no con cada pulsación de tecla;
- línea 37: un solo campo: [true] / [false];
- líneas 45–46: los campos de pasatiempos, gestionados manualmente: [[checked]] y [(change)], como en el ejemplo 04;
- líneas 54–59: una lista desplegable: la señal recibe el valor ([[value]], el código del país) de la opción seleccionada;
- línea 63: una lista de selección múltiple ([multiple]): la señal recibe la lista de valores seleccionados;
- línea 72: una fecha: la señal recibe una cadena ["yyyy-MM-dd"];
- línea 79: [{{ model() | json }}]: el modelo, en formato JSON, en tiempo real;
- línea 80: [@if (sent(); as text)]: si el valor es “verdadero” (en este caso, una cadena no vacía), se muestra el bloque, y [as text] lo convierte en una variable del bloque.
[npm start 05-ngmodel]; complete el formulario y luego envíelo:

[ngModel] existe desde la primera versión de [Angular] y acepta señales desde [Angular] 17. Se encuentra en innumerables aplicaciones. Sin embargo, deja en manos del componente todo lo que va más allá del simple intercambio de un valor: combinar campos, determinar cuáles se han modificado, validarlos... El siguiente ejemplo muestra la forma más reciente de escribir un formulario.
[Angular] 22 introduce una nueva forma de escribir formularios, basada por completo en señales: los formularios basados en señales ([Signal Forms], paquete [@angular/forms/signals]). El principio:
- el modelo del formulario es una señal, que contiene un objeto con una propiedad por campo;
- la función [form(model)] construye un árbol de campos ([FieldTree]) que tiene la misma estructura que el modelo: [f.lastName], [f.age], [f.newsletter]...;
- En la plantilla, [[formField]="f.lastName"] vincula un campo (HTML) con un campo del árbol.
El formulario lee y escribe en el modelo; y cada campo conoce su estado: ¿se ha accedido a él, se ha modificado, está deshabilitado, es válido?
| // =========================================================================
// 06-signal-forms/src/app/app.ts - formularios con signals
// -------------------------------------------------------------------------
// La forma moderna (Angular 22) de escribir un formulario:
// 1. el MODELO: un signal que contiene un objeto, con una propiedad por
// campo (el formulario lee y escribe en este signal);
// 2. form(model, schema): construye un ÁRBOL DE CAMPOS (FieldTree), que
// tiene la misma forma que el modelo: f.lastName, f.age, f.newsletter... El
// schema (opcional) describe las reglas de los campos (ver ejemplo 07);
// 3. [formField]="f.lastName" enlaza un campo HTML con un campo del árbol.
// Cada campo tiene un ESTADO, que se obtiene llamándolo: f.lastName() da su valor
// (value()), si ha sido tocado (touched()), modificado (dirty()), si está
// deshabilitado (disabled())...
// =========================================================================
import { Component, signal } from '@angular/core';
import { JsonPipe } from '@angular/common';
import { disabled, form, FormField } from '@angular/forms/signals';
// la forma de los datos del formulario
interface Profile {
title: string;
firstName: string;
lastName: string;
age: number;
newsletter: boolean;
email: string;
country: string;
birthDate: string;
presentation: string;
}
const INITIAL: Profile = {
title: 'Mme',
firstName: 'Marie',
lastName: 'PELISSIER',
age: 30,
newsletter: false,
email: '',
country: 'fr',
birthDate: '',
presentation: '',
};
@Component({
selector: 'app-root',
imports: [FormField, JsonPipe],
templateUrl: './app.html',
})
export class App {
protected readonly titles = ['Mr', 'Mme', 'Melle'];
// 1. el modelo
protected readonly model = signal<Profile>({ ...INITIAL });
// 2. el árbol de campos; una regla: el correo electrónico solo se puede modificar si la
// casilla "newsletter" está marcada (valueOf lee el valor de OTRO campo)
protected readonly f = form(this.model, (p) => {
disabled(p.email, ({ valueOf }) => !valueOf(p.newsletter));
});
// los campos cuyo estado se muestra, en la tabla de la derecha
protected readonly fields = ['firstName', 'lastName', 'age', 'email'] as const;
protected reset(): void {
// el modelo vuelve a su valor inicial, y el estado de los campos a cero
this.model.set({ ...INITIAL });
this.f().reset();
}
protected upperCase(): void {
// modificar el MODELO por código: los campos lo siguen
this.model.update((m) => ({ ...m, lastName: m.lastName.toUpperCase(), firstName: m.firstName.toUpperCase() }));
}
}
|
- línea 18: las funciones y la directiva de los formularios basados en señales;
- líneas 21–31: el formato de los datos del formulario;
- línea 47: el componente importa la directiva [FormField], que es la de [[formField]];
- línea 54: el modelo, una señal que contiene un objeto [Profile];
- líneas 58–60: el árbol de campos. El segundo argumento de [form] es el esquema del formulario: una función que recibe las rutas de los campos ([p.email], [p.newsletter]...) y les asocia reglas. Aquí solo hay una: [disabled(p.email, logic)] deshabilita el campo [email] cuando la función [logic] devuelve [true]. [valueOf(p.newsletter)] lee el valor de otro campo: la dirección de correo electrónico solo se puede editar si la casilla “newsletter” está seleccionada. La regla es reactiva: se vuelve a evaluar en cuanto cambia la casilla. El ejemplo 07 agregará reglas de validación;
- línea 63: los nombres de los campos cuyo estado muestra la plantilla; [as const] crea una lista de nombres exactos (['firstName' | 'lastName' | ...]), no cadenas arbitrarias;
- líneas 65–69: el restablecimiento. El modelo se restablece a su valor inicial (los campos lo siguen) y luego los estados de los campos se reinician ([touched], [dirty]): [f()] (el árbol, invocado) devuelve el estado de todo el formulario, incluido el método [reset()];
- Líneas 71–74: modificar el modelo desde el código; los campos de la página lo siguen.
La plantilla:
| <div class="container py-4">
<h1 class="h3 mb-3">Example 06 - signal forms</h1>
<div class="row g-4">
<form class="col-md-7" (submit)="$event.preventDefault()">
<div class="mb-3">
<span class="form-label d-block">Title</span>
<!-- botones de opción: el mismo campo, un valor por botón -->
@for (t of titles; track t) {
<div class="form-check form-check-inline">
<input type="radio" class="form-check-input" [id]="'title-' + t" [value]="t" [formField]="f.title">
<label class="form-check-label" [for]="'title-' + t">{{ t }}</label>
</div>
}
</div>
<div class="row g-3 mb-3">
<div class="col-5">
<label class="form-label" for="firstName">First name</label>
<!-- [formField]: este campo HTML edita el campo f.firstName del formulario -->
<input id="firstName" class="form-control" [formField]="f.firstName">
</div>
<div class="col-5">
<label class="form-label" for="lastName">Last name</label>
<input id="lastName" class="form-control" [formField]="f.lastName">
</div>
<div class="col-2">
<label class="form-label" for="age">Age</label>
<!-- type="number" y un modelo de tipo number: un valor numérico -->
<input id="age" type="number" class="form-control" [formField]="f.age">
</div>
</div>
<div class="row g-3 mb-3 align-items-end">
<div class="col-5">
<div class="form-check">
<input id="newsletter" type="checkbox" class="form-check-input" [formField]="f.newsletter">
<label for="newsletter" class="form-check-label">Receive the newsletter</label>
</div>
</div>
<div class="col-7">
<label class="form-label" for="email">E-mail (if newsletter)</label>
<!-- disabled lo gestiona el formulario: no hay que escribir ningún atributo aquí -->
<input id="email" type="email" class="form-control" [formField]="f.email">
</div>
</div>
<div class="row g-3 mb-3">
<div class="col-6">
<label class="form-label" for="country">Country</label>
<select id="country" class="form-select" [formField]="f.country">
<option value="fr">France</option>
<option value="be">Belgium</option>
<option value="ch">Switzerland</option>
</select>
</div>
<div class="col-6">
<label class="form-label" for="birthDate">Date of birth</label>
<input id="birthDate" type="date" class="form-control" [formField]="f.birthDate">
</div>
</div>
<div class="mb-3">
<label class="form-label" for="presentation">Presentation</label>
<textarea id="presentation" rows="2" class="form-control" [formField]="f.presentation"></textarea>
</div>
<div class="d-flex gap-2">
<button type="button" class="btn btn-outline-primary" (click)="upperCase()">Name in upper case</button>
<button type="button" class="btn btn-outline-secondary" (click)="reset()">Reset</button>
</div>
</form>
<div class="col-md-5">
<h2 class="h6">The model, live</h2>
<!-- f().value(): el valor de todo el formulario, es decir, el modelo -->
<pre class="bg-light p-2 rounded small">{{ f().value() | json }}</pre>
<h2 class="h6">The state of the fields</h2>
<table class="table table-sm small">
<thead><tr><th>field</th><th>touched</th><th>dirty</th><th>disabled</th></tr></thead>
<tbody>
@for (c of fields; track c) {
<tr>
<td>{{ c }}</td>
<td>{{ f[c]().touched() }}</td>
<td>{{ f[c]().dirty() }}</td>
<td>{{ f[c]().disabled() }}</td>
</tr>
}
</tbody>
</table>
<p class="small mb-0">form modified (dirty): <strong>{{ f().dirty() }}</strong></p>
</div>
</div>
</div>
|
- línea 4: el formulario no se envía (en este ejemplo no hay botón de envío); solo se impide el envío con la tecla Enter;
- línea 10: botones de opción: el mismo campo [f.title] en cada botón, un valor por botón;
- línea 19: [[formField]="f.firstName"] vincula el campo HTML con el campo [firstName] del formulario, en ambos sentidos, como con [ngModel] en el ejemplo 05;
- línea 28: un campo numérico, para una propiedad numérica del modelo: el modelo recibe un número;
- línea 34: una casilla de verificación, para un valor booleano;
- línea 41: el campo [email]. No especifique el atributo [disabled]: la directiva [[formField]] lo establece y lo quita automáticamente, según la regla del esquema;
- líneas 47, 55, 60: una lista desplegable, una fecha, un cuadro de texto;
- Línea 71: [f().value()]: el valor de todo el formulario, es decir, el modelo;
- Líneas 76–83: el estado de cuatro campos. [f[c]] es el campo con el nombre [c]; [fc] es su estado; [touched()] (el usuario entró en el campo y luego salió de él), [dirty()] (el usuario cambió su valor), [disabled()]: todos son señales;
- Línea 86: el estado de todo el formulario; se actualiza si se modifica cualquiera de sus campos.
[npm start 06-signal-forms]; seleccione el tratamiento, escriba un nombre, un apellido y una edad, marque la casilla (el campo de correo electrónico pasa a ser editable), escriba la dirección de correo y luego haga clic en “Name in upper case”:

En comparación con [ngModel]: una sola señal para todo el formulario y el estado de cada campo, sin tener que escribir nada. Los formularios basados en señales no pueden vincular varias casillas de verificación a la misma lista, ni vincularse a una lista de selección múltiple: para estos campos, use la técnica del ejemplo 05.
El formulario “Crear una cuenta” de la aplicación [RdvMedecins], validado en el navegador con las mismas reglas que el servidor: tratamiento incluido en la lista, nombre y apellido obligatorios (máximo 20 caracteres), nombre de usuario en minúsculas, contraseña de al menos 6 caracteres, confirmación.
Nota: esta validación es solo una comodidad para el usuario (una respuesta inmediata, sin intercambios con el servidor). No ofrece ninguna seguridad: cualquiera puede enviar al servidor una solicitud construida manualmente ([curl]...). Por lo tanto, el servidor SIEMPRE validará también (véase el ejemplo 25).
2.7.1. Configuración de la aplicación
| import { bootstrapApplication } from '@angular/platform-browser';
import { provideSignalFormsConfig } from '@angular/forms/signals';
import { App } from './app/app';
bootstrapApplication(App, {
providers: [
provideSignalFormsConfig({
classes: {
// un campo con error solo se señala una vez "touched" (abandonado)
'is-invalid': (field) => field.state().touched() && field.state().invalid(),
'is-valid': (field) => field.state().touched() && field.state().valid(),
},
}),
],
}).catch((error) => console.error(error));
|
- línea 15: el segundo argumento de [bootstrapApplication] es la configuración de la aplicación: una lista de proveedores ([providers]), que ponen servicios y ajustes a disposición de toda la aplicación (véase el ejemplo 14);
- Líneas 17–23: [provideSignalFormsConfig] configura los formularios basados en señales. [classes] asocia una clase CSS con una condición basada en el estado de un campo: la directiva [[formField]] aplica la clase al campo HTML cuando la condición es verdadera. Se utilizan las siguientes clases de [Bootstrap]:
- línea 20: [is-invalid] (borde rojo), si se ha entrado en el campo pero es inválido (ambas condiciones). Los errores no se muestran de inmediato: un formulario vacío cubierto de rojo resulta poco agradable;
- línea 21: [is-valid] (recuadro verde), si se ha entrado en el campo y es válido.
2.7.2. El componente
| // =========================================================================
// 07-validation/src/app/app.ts - validar un formulario en el navegador
// -------------------------------------------------------------------------
// Las reglas de los campos se escriben en el SCHEMA del formulario (segundo
// argumento de form()): required, maxLength, minLength, pattern... y
// validate() para una regla "casera". Cada campo conoce entonces sus
// errores (f.lastName().errors()), recalculados en cada pulsación de tecla.
// No se muestran de inmediato (un formulario vacío cubierto de rojo es
// desagradable): solo para un campo ya abandonado ("touched"). submit()
// marca todos los campos como touched, y luego solo ejecuta la acción si el
// formulario es válido.
//
// Mismas reglas que el servidor RdvMedecins (formulario "Crear una cuenta").
// ADVERTENCIA: esta validación es solo una COMODIDAD para el usuario (una
// respuesta inmediata, sin ida y vuelta al servidor). No protege
// nada: cualquiera puede enviar al servidor una petición construida
// a mano (curl...). Por lo tanto, el servidor SIEMPRE revalida todo (ver ejemplo 25).
// =========================================================================
import { Component, signal } from '@angular/core';
import { form, FormField, maxLength, minLength, pattern, required, submit, validate } from '@angular/forms/signals';
interface Account {
title: string;
firstName: string;
lastName: string;
login: string;
password: string;
confirmation: string;
}
const TITLES = ['Mr', 'Mme', 'Melle'];
const LOGIN_FORMAT = /^[a-z0-9._-]{1,30}$/;
const PASSWORD_MIN = 6;
@Component({
selector: 'app-root',
imports: [FormField],
templateUrl: './app.html',
})
export class App {
protected readonly titles = TITLES;
protected readonly model = signal<Account>({
title: 'Mr',
firstName: '',
lastName: '',
login: '',
password: '',
confirmation: '',
});
// el schema: p designa las RUTAS de los campos (p.lastName, p.login...)
protected readonly f = form(this.model, (p) => {
validate(p.title, ({ value }) =>
TITLES.includes(value()) ? null : { kind: 'title', message: 'Choose a title from the list.' },
);
required(p.firstName, { message: 'The first name is required.' });
maxLength(p.firstName, 20, { message: 'The first name must not exceed 20 characters.' });
required(p.lastName, { message: 'The last name is required.' });
maxLength(p.lastName, 20, { message: 'The last name must not exceed 20 characters.' });
required(p.login, { message: 'The login is required.' });
pattern(p.login, LOGIN_FORMAT, { message: 'Unaccented lower-case letters, digits, dot, hyphen, underscore.' });
required(p.password, { message: 'The password is required.' });
minLength(p.password, PASSWORD_MIN, { message: `At least ${PASSWORD_MIN} characters.` });
// una regla "casera", que compara DOS campos (valueOf lee el otro)
validate(p.confirmation, ({ value, valueOf }) =>
value() === valueOf(p.password)
? null
: { kind: 'confirmation', message: 'The confirmation does not match the password.' },
);
});
protected readonly submitAttempted = signal(false);
protected readonly success = signal(false);
// (submit) del formulario
protected async send(event: SubmitEvent): Promise<void> {
event.preventDefault();
this.submitAttempted.set(true);
// submit() marca todos los campos como touched (aparecen sus errores),
// y luego solo ejecuta la acción si todo es válido
const valid = await submit(this.f, async () => {
// aquí enviaríamos el modelo al servidor (ver ejemplo 25)
return null; // null: sin error
});
this.success.set(valid);
}
}
|
- línea 21: funciones de validación para formularios basados en señales;
- líneas 53–71: el esquema del formulario: cada función asocia una regla con un campo, identificado por su ruta ([p.firstName]), junto con el mensaje que se mostrará en caso de fallo:
- [required]: el campo debe completarse;
- [maxLength], [minLength]: una longitud máxima o mínima;
- [pattern]: el valor debe coincidir con una expresión regular;
- [validate(path, function)]: una regla “personalizada”. La función recibe el contexto del campo (su valor [value()], el valor de otro campo [valueOf(...)]) y devuelve [null] (sin error) o un error: un objeto [{ kind, message }], donde [kind] indica el tipo de error (líneas 54–56 y 66–70). La regla de confirmación compara dos campos: se vuelve a evaluar cuando cambia uno U otro;
- [Angular] también proporciona [email], [min], [max] y reglas asíncronas ([validateHttp]), que consultan a un servidor;
- líneas 77–87: el envío. [submit(form, action)]:
- marca todos los campos como tocados: sus errores aparecen, incluso los de aquellos que el usuario nunca ha visitado;
- ejecuta la acción solo si el formulario es válido;
- devuelve [true] si el envío tuvo éxito. La acción devuelve [null] cuando todo sale bien, o códigos de error, que el ejemplo 25 obtendrá del servidor.
2.7.3. La plantilla
| <div class="container py-4" style="max-width: 640px">
<h1 class="h3 mb-3">Example 07 - validating a form</h1>
<!-- novalidate: deshabilitamos la validación propia del navegador, para
mostrar NUESTROS mensajes, con NUESTRO estilo -->
<form class="card p-4" novalidate (submit)="send($event)">
<div class="mb-3">
<label class="form-label" for="title">Title</label>
<select id="title" class="form-select" [formField]="f.title">
@for (t of titles; track t) {
<option [value]="t">{{ t }}</option>
}
</select>
<div class="invalid-feedback">{{ f.title().errors()[0]?.message }}</div>
</div>
<div class="row g-3 mb-3">
<div class="col-sm-6">
<label class="form-label" for="firstName">First name</label>
<!-- la clase is-invalid (establecida por la configuración, véase main.ts)
da al campo un borde rojo Y revela el .invalid-feedback
que lo sigue: ahí escribimos el primer error del campo -->
<input id="firstName" class="form-control" [formField]="f.firstName">
<div class="invalid-feedback">{{ f.firstName().errors()[0]?.message }}</div>
</div>
<div class="col-sm-6">
<label class="form-label" for="lastName">Last name</label>
<input id="lastName" class="form-control" [formField]="f.lastName">
<div class="invalid-feedback">{{ f.lastName().errors()[0]?.message }}</div>
</div>
</div>
<div class="mb-3">
<label class="form-label" for="login">Login</label>
<input id="login" class="form-control" autocomplete="username" [formField]="f.login">
<div class="invalid-feedback">{{ f.login().errors()[0]?.message }}</div>
</div>
<div class="row g-3 mb-4">
<div class="col-sm-6">
<label class="form-label" for="password">Password</label>
<input id="password" type="password" class="form-control" autocomplete="new-password" [formField]="f.password">
<div class="invalid-feedback">{{ f.password().errors()[0]?.message }}</div>
</div>
<div class="col-sm-6">
<label class="form-label" for="confirmation">Confirmation</label>
<input id="confirmation" type="password" class="form-control" autocomplete="new-password"
[formField]="f.confirmation">
<div class="invalid-feedback">{{ f.confirmation().errors()[0]?.message }}</div>
</div>
</div>
<button type="submit" class="btn btn-primary">Create the account</button>
@if (submitAttempted() && f().invalid()) {
<div class="alert alert-danger mt-3 mb-0">The form contains {{ f().errorSummary().length }} error(s).</div>
}
@if (success()) {
<div class="alert alert-success mt-3 mb-0">Valid form: it could be sent to the server.</div>
}
</form>
</div>
|
- línea 5: [novalidate] desactiva la validación propia del navegador (los mensajes emergentes “Please fill in this field”): se muestran NUESTROS mensajes con NUESTRO estilo;
- Línea 13: [f.title().errors()]: la lista de errores del campo, recalculada con cada cambio. Se muestra el mensaje del primero. [?.]: si no hay errores, [[0]] es igual a [undefined], y la expresión también;
- Líneas 21–22: el campo y su área de mensaje. La clase [invalid-feedback] de [Bootstrap] está oculta, a menos que siga a un campo que tenga la clase [is-invalid]: por lo tanto, no se necesita código para que aparezca en el momento adecuado;
- línea 49: [f().invalid()]: el formulario es inválido si alguno de sus campos es inválido; [f().errorSummary()] (línea 50): los errores de todos sus campos.
[npm start 07-validation]; escriba un nombre, pase al apellido, déjelo en blanco, escriba un nombre de usuario incorrecto:

Solo los campos que se han completado se resaltan, en verde o en rojo. Haga clic en “Create the account” con el formulario vacío: todos los campos se resaltan:

El campo de confirmación vacío es “válido”: coincide con la contraseña, que también está vacía. Un formulario válido:

Antes de los formularios basados en señales, los formularios de [Angular] se escribían con [ngModel] (ejemplo 05) o con formularios reactivos ([ReactiveFormsModule]), esta última API es la más utilizada en las aplicaciones existentes. Es seguro que se la encontrará: aquí está el formulario del ejemplo 07, reescrito con ella.
| // =========================================================================
// 08-reactive-forms/src/app/app.ts - la API "histórica" de formularios
// -------------------------------------------------------------------------
// Antes de los formularios con signals (Angular 22), los formularios se escribían
// con FORMULARIOS REACTIVOS (ReactiveFormsModule). Se encuentran en
// la mayoría de las aplicaciones existentes: este es el formulario del ejemplo
// 07, reescrito con ellos.
// - un FormGroup reúne FormControls, uno por campo;
// - cada FormControl tiene un valor inicial y VALIDADORES
// (Validators.required, Validators.maxLength(20)...);
// - en la plantilla, [formGroup] enlaza el <form> con el grupo, y
// formControlName="lastName" enlaza un campo HTML con un control;
// - el estado de un control (value, errors, touched, invalid...) es una
// propiedad ordinaria, no un signal.
// =========================================================================
import { Component, inject, signal } from '@angular/core';
import { AbstractControl, FormBuilder, ReactiveFormsModule, ValidationErrors, Validators } from '@angular/forms';
const TITLES = ['Mr', 'Mme', 'Melle'];
// un validador "casero" se aplica al GRUPO: compara dos de sus campos.
// Devuelve null (sin error) o un objeto que describe el error.
function sameConfirmation(group: AbstractControl): ValidationErrors | null {
const password = group.get('password')?.value;
const confirmation = group.get('confirmation')?.value;
return password === confirmation ? null : { confirmation: true };
}
@Component({
selector: 'app-root',
imports: [ReactiveFormsModule],
templateUrl: './app.html',
})
export class App {
protected readonly titles = TITLES;
private readonly fb = inject(FormBuilder).nonNullable;
// el grupo: { name: [valor inicial, validadores] }
protected readonly form = this.fb.group(
{
title: ['Mr', [Validators.required]],
firstName: ['', [Validators.required, Validators.maxLength(20)]],
lastName: ['', [Validators.required, Validators.maxLength(20)]],
login: ['', [Validators.required, Validators.pattern(/^[a-z0-9._-]{1,30}$/)]],
password: ['', [Validators.required, Validators.minLength(6)]],
confirmation: [''],
},
{ validators: sameConfirmation },
);
protected readonly success = signal(false);
protected readonly value = signal('');
// un campo se señala con error si ha sido tocado y es inválido
protected inError(name: string): boolean {
const control = this.form.get(name);
return !!control && control.touched && control.invalid;
}
// (ngSubmit): todos los campos pasan a "touched", aparecen sus errores
protected send(): void {
this.form.markAllAsTouched();
this.success.set(this.form.valid);
// getRawValue(): el valor de todo el grupo, tipado
this.value.set(JSON.stringify(this.form.getRawValue()));
}
}
|
- línea 18: las clases de los formularios reactivos, en [@angular/forms];
- líneas 24–28: un validador “personalizado”. Es una función que recibe un control (en este caso, el grupo completo, para comparar dos de sus campos) y devuelve [null] (sin error) o un objeto que describe el error;
- línea 32: el componente importa [ReactiveFormsModule], que proporciona las directivas [[formGroup]] y [formControlName];
- línea 37: [inject(FormBuilder)]: el componente solicita un servicio a [Angular] (inyección de dependencias; véase el ejemplo 14). [FormBuilder] ayuda a generar formularios; [nonNullable]: un campo restablecido vuelve a su valor inicial, no a [null];
- Líneas 40–50: el formulario es un grupo ([FormGroup]) de controles ([FormControl]), uno por campo. Cada uno se describe mediante su valor inicial y la lista de sus validadores: [Validators.required], [Validators.maxLength(20)], [Validators.pattern(...)]... Línea 49: el validador del grupo;
- Líneas 56–59: un campo se marca como erróneo si ha sido modificado y es inválido. El estado de un control ([touched], [invalid], [errors], [value]) es una propiedad ordinaria, no una señal;
- Líneas 62–67: el envío. [markAllAsTouched()] muestra todos los errores; [valid] indica si todo el grupo es válido; [getRawValue()] devuelve su valor, tipado según la descripción del grupo.
La plantilla:
| <div class="container py-4" style="max-width: 640px">
<h1 class="h3 mb-3">Example 08 - reactive forms</h1>
<!-- [formGroup]: este <form> está controlado por el grupo "form" -->
<form class="card p-4" novalidate [formGroup]="form" (ngSubmit)="send()">
<div class="mb-3">
<label class="form-label" for="title">Title</label>
<!-- formControlName: este campo es el control "title" del grupo -->
<select id="title" class="form-select" formControlName="title">
@for (t of titles; track t) {
<option [value]="t">{{ t }}</option>
}
</select>
</div>
<div class="row g-3 mb-3">
<div class="col-sm-6">
<label class="form-label" for="firstName">First name</label>
<input id="firstName" class="form-control" formControlName="firstName" [class.is-invalid]="inError('firstName')">
<!-- errors: un objeto en el que cada clave es el nombre de un validador que falla -->
<div class="invalid-feedback">
@if (form.controls.firstName.errors?.['required']) { The first name is required. }
@if (form.controls.firstName.errors?.['maxlength']) { 20 characters at most. }
</div>
</div>
<div class="col-sm-6">
<label class="form-label" for="lastName">Last name</label>
<input id="lastName" class="form-control" formControlName="lastName" [class.is-invalid]="inError('lastName')">
<div class="invalid-feedback">
@if (form.controls.lastName.errors?.['required']) { The last name is required. }
@if (form.controls.lastName.errors?.['maxlength']) { 20 characters at most. }
</div>
</div>
</div>
<div class="mb-3">
<label class="form-label" for="login">Login</label>
<input id="login" class="form-control" formControlName="login" [class.is-invalid]="inError('login')">
<div class="invalid-feedback">
@if (form.controls.login.errors?.['required']) { The login is required. }
@if (form.controls.login.errors?.['pattern']) { Unaccented lower-case letters, digits, dot, hyphen, underscore. }
</div>
</div>
<div class="row g-3 mb-4">
<div class="col-sm-6">
<label class="form-label" for="password">Password</label>
<input id="password" type="password" class="form-control" formControlName="password"
[class.is-invalid]="inError('password')">
<div class="invalid-feedback">
@if (form.controls.password.errors?.['required']) { The password is required. }
<!-- los errores también llevan información: la longitud requerida -->
@if (form.controls.password.errors?.['minlength']; as e) { At least {{ e.requiredLength }} characters. }
</div>
</div>
<div class="col-sm-6">
<label class="form-label" for="confirmation">Confirmation</label>
<!-- el error "confirmation" es el del GRUPO (validador casero) -->
<input id="confirmation" type="password" class="form-control" formControlName="confirmation"
[class.is-invalid]="form.controls.confirmation.touched && form.hasError('confirmation')">
<div class="invalid-feedback">The confirmation does not match the password.</div>
</div>
</div>
<button type="submit" class="btn btn-primary">Create the account</button>
@if (value()) {
<div class="alert mt-3 mb-0" [class]="success() ? 'alert-success' : 'alert-danger'">
{{ success() ? 'Valid form' : 'Invalid form' }}: <code>{{ value() }}</code>
</div>
}
</form>
</div>
|
- línea 4: [[formGroup]] vincula el formulario HTML con el grupo; [(ngSubmit)] llama al método de envío;
- línea 8: [formControlName="title"] vincula el campo con el control [title] del grupo;
- línea 17: la clase [is-invalid] la establece la plantilla mediante el método [inError];
- líneas 20–21: [errors] es un objeto cuyas propiedades se llaman como los validadores que fallaron ([required], [maxlength]...). Se escribe un mensaje para cada error posible;
- línea 49: un error también contiene información: en este caso, la longitud requerida;
- línea 56: el error de confirmación es el del grupo: [form.hasError('confirmation')].
[npm start 08-reactive-forms]; algunos errores y luego un clic en “Create the account”:

Ambas API cumplen la misma función. Los formularios reactivos describen el formulario en el código (controles que contienen el valor Y el estado), mientras que los formularios basados en señales parten de los datos (un modelo al que se asocian reglas) y se integran de forma natural con las señales del resto de la aplicación. Son los que usaremos en el resto del curso y en el caso de estudio.
2.9. Ejemplo 09: pipes
Un pipe da formato a un valor para mostrarlo sin modificarlo: [{{ value | pipe }}] o, con parámetros, [{{ value | pipe: parameter1 : parameter2 }}]. [Angular] proporciona una docena; usted puede escribir los suyos.
2.9.1. El idioma de los pipes
Los pipes de fechas y números dan formato a los valores según un idioma ([locale]). De forma predeterminada, [Angular] solo admite el inglés de Estados Unidos. Para el inglés británico:
| import { LOCALE_ID } from '@angular/core';
import { registerLocaleData } from '@angular/common';
import localeEnGb from '@angular/common/locales/en-GB';
import { bootstrapApplication } from '@angular/platform-browser';
import { App } from './app/app';
registerLocaleData(localeEnGb);
bootstrapApplication(App, {
providers: [{ provide: LOCALE_ID, useValue: 'en-GB' }],
}).catch((error) => console.error(error));
|
- línea 18: [registerLocaleData(localeEnGb)] carga las reglas británicas: nombres de días y meses, orden del día y el mes, formatos de fecha, etc.;
- línea 21: un proveedor que asigna un valor al token [LOCALE_ID]: el idioma predeterminado que usan los pipes. [{ provide: token, useValue: value }] es la forma más simple de un proveedor; el ejemplo 14 volverá sobre esto.
2.9.2. Dos pipes personalizados
Un pipe es una clase decorada con [@Pipe], cuyo método [transform] recibe el valor colocado antes de la barra, junto con los parámetros eventuales:
| // =========================================================================
// 09-pipes/src/app/pipes/time-range.pipe.ts - un pipe "casero"
// -------------------------------------------------------------------------
// Un pipe es una clase decorada con @Pipe, cuyo método transform()
// recibe el valor colocado ANTES de la barra (y, eventualmente,
// parámetros) y devuelve lo que debe mostrarse:
// {{ slot | timeRange }} -> "8:00 - 8:20"
// {{ slot | timeRange: 'start' }} -> "8:00"
// Un pipe es "puro" por defecto: Angular solo vuelve a llamar a transform() si el
// valor o los parámetros han CAMBIADO (mismo objeto = mismo resultado).
// =========================================================================
import { Pipe, PipeTransform } from '@angular/core';
export interface Slot {
startHour: number;
startMinute: number;
endHour: number;
endMinute: number;
}
// "8:05" en lugar de "8:5"
function time(h: number, m: number): string {
return `${h}:${String(m).padStart(2, '0')}`;
}
@Pipe({ name: 'timeRange' })
export class TimeRangePipe implements PipeTransform {
transform(c: Slot, part: 'all' | 'start' | 'end' = 'all'): string {
switch (part) {
case 'start':
return time(c.startHour, c.startMinute);
case 'end':
return time(c.endHour, c.endMinute);
default:
return `${time(c.startHour, c.startMinute)} - ${time(c.endHour, c.endMinute)}`;
}
}
}
|
- línea 27: el nombre del pipe, el que se escribe en las plantillas;
- línea 29: [transform(value, part)] devuelve lo que debe mostrarse. El parámetro es opcional (valor predeterminado ['all']): [{{ slot | timeRange }}] muestra [8:00 - 8:20], [{{ slot | timeRange: 'start' }}] muestra [8:00].
Un pipe es puro de forma predeterminada: [Angular] solo llama a [transform] si el valor o alguno de los parámetros ha cambiado (un objeto distinto, una cadena distinta). Esto es lo que lo hace más eficiente que un método del componente llamado dentro de la plantilla (como [format(...)] en el ejemplo 02), que se ejecuta cada vez que se verifica el componente.
Un segundo pipe, que calcula las iniciales:
| // 09-pipes/src/app/pipes/initials.pipe.ts - "Marie PELISSIER" -> "MP"
import { Pipe, PipeTransform } from '@angular/core';
@Pipe({ name: 'initials' })
export class InitialsPipe implements PipeTransform {
transform(fullName: string): string {
return fullName
.split(/\s+/)
.filter((word) => word !== '')
.map((word) => word[0].toUpperCase())
.join('');
}
}
|
2.9.3. El componente y su plantilla
| // =========================================================================
// 09-pipes/src/app/app.ts - dar formato a los valores en una plantilla
// -------------------------------------------------------------------------
// {{ value | pipe }} o {{ value | pipe: parameter1 : parameter2 }}:
// un PIPE transforma un valor para mostrarlo, sin modificarlo. Angular
// proporciona una decena (módulo @angular/common); se pueden escribir
// propios (ver pipes/). Un componente importa los pipes que usa.
// =========================================================================
import { Component, signal } from '@angular/core';
import {
CurrencyPipe,
DatePipe,
DecimalPipe,
JsonPipe,
KeyValuePipe,
LowerCasePipe,
PercentPipe,
SlicePipe,
TitleCasePipe,
UpperCasePipe,
} from '@angular/common';
import { Slot, TimeRangePipe } from './pipes/time-range.pipe';
import { InitialsPipe } from './pipes/initials.pipe';
@Component({
selector: 'app-root',
imports: [
CurrencyPipe,
DatePipe,
DecimalPipe,
JsonPipe,
KeyValuePipe,
LowerCasePipe,
PercentPipe,
SlicePipe,
TitleCasePipe,
UpperCasePipe,
TimeRangePipe,
InitialsPipe,
],
templateUrl: './app.html',
})
export class App {
protected readonly now = signal(new Date());
protected readonly day = '2026-10-05'; // una fecha en el formato de la API de RdvMedecins
protected readonly price = 1234.5;
protected readonly rate = 0.055;
protected readonly name = 'marie pelissier';
protected readonly doctor = { title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER' };
protected readonly slots: Slot[] = [
{ startHour: 8, startMinute: 0, endHour: 8, endMinute: 20 },
{ startHour: 8, startMinute: 20, endHour: 8, endMinute: 40 },
{ startHour: 14, startMinute: 5, endHour: 14, endMinute: 25 },
];
protected readonly languages = ['TypeScript', 'HTML', 'CSS', 'JavaScript', 'SQL'];
protected refresh(): void {
this.now.set(new Date());
}
}
|
- Líneas 11–22 y 28–41: un componente importa los pipes que utiliza, incluidos los de [Angular] ([@angular/common]), como propios;
- línea 46: una fecha en el formato de la API de [RdvMedecins]: el pipe [date] acepta un objeto [Date], un número (milisegundos) o una cadena ISO.
| <div class="container py-4" style="max-width: 820px">
<h1 class="h3 mb-3">Example 09 - pipes</h1>
<table class="table table-sm align-middle">
<thead><tr><th>In the template</th><th>Displayed</th></tr></thead>
<tbody>
<tr><td><code>{{ '{{' }} now() | date {{ '}}' }}</code></td><td>{{ now() | date }}</td></tr>
<tr><td><code>{{ '{{' }} now() | date: 'fullDate' {{ '}}' }}</code></td><td>{{ now() | date: 'fullDate' }}</td></tr>
<tr><td><code>{{ '{{' }} now() | date: 'HH:mm:ss' {{ '}}' }}</code></td><td>{{ now() | date: 'HH:mm:ss' }}</td></tr>
<tr><td><code>{{ '{{' }} day | date: 'EEEE d MMMM y' {{ '}}' }}</code></td><td>{{ day | date: 'EEEE d MMMM y' }}</td></tr>
<tr><td><code>{{ '{{' }} day | date: 'longDate' : '' : 'en-US' {{ '}}' }}</code></td><td>{{ day | date: 'longDate' : '' : 'en-US' }}</td></tr>
<tr><td><code>{{ '{{' }} price | currency: 'EUR' {{ '}}' }}</code></td><td>{{ price | currency: 'EUR' }}</td></tr>
<tr><td><code>{{ '{{' }} price | number: '1.0-0' {{ '}}' }}</code></td><td>{{ price | number: '1.0-0' }}</td></tr>
<tr><td><code>{{ '{{' }} rate | percent: '1.1-1' {{ '}}' }}</code></td><td>{{ rate | percent: '1.1-1' }}</td></tr>
<tr><td><code>{{ '{{' }} name | uppercase {{ '}}' }}</code></td><td>{{ name | uppercase }}</td></tr>
<tr><td><code>{{ '{{' }} name | titlecase {{ '}}' }}</code></td><td>{{ name | titlecase }}</td></tr>
<tr><td><code>{{ '{{' }} 'APPOINTMENT' | lowercase {{ '}}' }}</code></td><td>{{ 'APPOINTMENT' | lowercase }}</td></tr>
<tr><td><code>{{ '{{' }} languages | slice: 0 : 3 {{ '}}' }}</code></td><td>{{ languages | slice: 0 : 3 }}</td></tr>
<tr><td><code>{{ '{{' }} doctor | json {{ '}}' }}</code></td><td><code>{{ doctor | json }}</code></td></tr>
<!-- dos pipes seguidos: el resultado del primero pasa al segundo -->
<tr><td><code>{{ '{{' }} name | titlecase | initials {{ '}}' }}</code></td><td>{{ name | titlecase | initials }}</td></tr>
</tbody>
</table>
<h2 class="h6">keyvalue: iterating over the properties of an object</h2>
<ul>
@for (p of doctor | keyvalue; track p.key) {
<li>{{ p.key }} = {{ p.value }}</li>
}
</ul>
<h2 class="h6">A home-made pipe: timeRange</h2>
<ul>
@for (c of slots; track $index) {
<li>{{ c | timeRange }} (start: {{ c | timeRange: 'start' }})</li>
}
</ul>
<button class="btn btn-sm btn-outline-primary" (click)="refresh()">Refresh the time</button>
</div>
|
- líneas 6–20: una línea por pipe: la expresión, seguida de su resultado. [{{ '{{' }}] muestra los caracteres [{{], que no se pueden escribir tal cual en una plantilla;
- Líneas 6–10: el pipe [date], con un formato predefinido ([fullDate], [longDate]...) o un formato compuesto ([EEEE d MMMM y], [HH:mm:ss]). Línea 10: sus parámetros segundo y tercero son la zona horaria y el idioma: en este caso, el inglés de Estados Unidos ([en-US]), solo para esta fecha;
- línea 11: [currency], un importe en una moneda;
- línea 12: [number: '1.0-0']: al menos 1 dígito antes del separador decimal, entre 0 y 0 dígitos después: redondeado al entero más cercano;
- línea 13: [percent], un porcentaje;
- líneas 14–16: mayúsculas, iniciales en mayúscula, minúsculas;
- línea 17: [slice], una parte de una lista o de una cadena;
- línea 18: [json], un objeto en formato JSON (muy útil para depurar);
- línea 20: dos pipes seguidos: el resultado del primero se pasa al segundo;
- línea 26: [keyvalue] convierte un objeto en una lista de pares [{ key, value }] que [@for] puede recorrer;
- línea 34: nuestro pipe [timeRange], primero sin parámetro y luego con él.
[npm start 09-pipes]:

[Angular] también proporciona el pipe [async], que muestra el último valor de un observable (véase el ejemplo 19), y [i18nPlural] para los plurales. [ngx-translate] proporciona el pipe [translate], que traduce texto (ejemplo 21).