5. Capítulo 4 - Introducción a [Angular]
5.1. Fuentes
Este capítulo se basa en la documentación oficial de [Angular]: angular.dev.
5.2. De AngularJS 1.x a [Angular]
El documento original (2014) utilizaba AngularJS 1.x: un framework (JavaScript, todavía no TypeScript) organizado en torno a $scope, controladores, directivas (ng-repeat, ng-if…) y un mecanismo de detección de cambios basado en el “ciclo de digestión” ($digest) y en la observación de variables ($watch).
A partir de 2016, este framework se reescribió por completo con el nombre de [Angular] (sin “JS”), en TypeScript, con una arquitectura basada en componentes. Siguieron versiones posteriores (2, 4… hasta la 22, que se usa en este documento), con dos cambios importantes que conviene conocer antes de trabajar con el código del cliente [RdvMedecins]:
- el abandono progresivo de NgModules (@NgModule) en favor de componentes independientes (standalone) y autosuficientes;
- la introducción de los signals (signal()), un nuevo modelo de reactividad que reemplaza a $watch/$digest.
Este capítulo presenta estos conceptos uno por uno, con ejemplos breves independientes del caso de estudio; el capítulo siguiente los mostrará en acción dentro del cliente [RdvMedecins] completo.
5.3. El concepto de aplicación [Angular]: la “aplicación de página única”
Una aplicación [Angular] es una aplicación de página única (SPA): el servidor entrega al navegador solo una única página (HTML), que contiene un único archivo JavaScript con toda la lógica de la aplicación. Una vez cargada esta página, nunca vuelve a haber una recarga completa de página: cada interacción del usuario (cambiar de vista, enviar un formulario, etc.) la gestiona el código JavaScript que ya está en el navegador, que actualiza la pantalla y se comunica con el servidor en segundo plano mediante solicitudes HTTP asíncronas (casi siempre con JSON). Este ya era el principio del documento original con AngularJS 1.x; no ha cambiado.
5.4. Componentes
Un componente es la unidad básica de una aplicación [Angular]: asocia una vista (una plantilla HTML) con una clase TypeScript que gestiona su estado y su comportamiento; exactamente el papel que desempeñaba, en el documento original, el par “vista + controlador C” de AngularJS 1.x, pero aquí combinados en una sola entidad.
A continuación se muestra un componente muy pequeño, independiente del caso de estudio, que podría crearse con ng generate component counter:
- línea 4: [@Component]({...}) es un decorador (el mismo mecanismo que en [NestJS]; véase el Capítulo 2) que declara la clase siguiente como un componente de [Angular];
- línea 5: selector: 'app-counter': el nombre de la etiqueta HTML personalizada (<app-counter>) que, al usarse en la plantilla de otro componente, inserta ese componente en ese lugar; es el mecanismo de composición de vistas, ya presente (de otra forma, las directivas) en AngularJS 1.x;
- línea 6: templateUrl: el archivo HTML asociado a este componente (también puede escribirse el HTML directamente en el decorador, mediante la propiedad template);
- línea 9: signal(0) crea un valor reactivo inicializado en 0 (véase la sección siguiente);
- línea 16: {{ value() }} en la plantilla: las llaves dobles muestran un valor calculado por la clase; una sintaxis idéntica a la de AngularJS 1.x, pero observe los paréntesis: `value` es un signal y, por lo tanto, una función que debe llamarse para leer su valor actual;
- línea 17: (click)="increment()": los paréntesis alrededor de `click` significan “escuchar el evento click del `DOM`” y llamar al método indicado; es el equivalente exacto de la directiva `ng-click` de `AngularJS` 1.x.
5.5. Signals: el nuevo modelo de reactividad
En AngularJS 1.x, [Angular] detectaba los cambios de datos mediante un bucle de verificación sistemático (el $digest), que recorría todas las expresiones observadas ($watch) en cada posible interacción. Este mecanismo, aunque sencillo de usar, se volvía costoso a medida que la aplicación crecía.
Un signal es un contenedor de valor que sabe cuándo cambia y sabe qué depende de él (una plantilla, otro cálculo, etc.); así, [Angular] ya no necesita volver a verificarlo todo: solo se recalculan las partes de la aplicación que dependen realmente de un signal modificado. Tres funciones bastan para entender lo básico:
Función | Papel |
crea un signal; su valor se lee llamándolo como una función: mySignal() | |
reemplaza el valor del signal | |
calcula el nuevo valor a partir del anterior (véase increment() más arriba) | |
crea un signal que se calcula automáticamente a partir de otros signals y se recalcula solo cuando es necesario |
Se utilizan dos variantes especializadas de signal() para que un componente se comunique con su padre; aparecen con frecuencia en el cliente [RdvMedecins] (véase el capítulo siguiente):
- input() (y su variante input.required()) declara una entrada: un valor proporcionado por el componente padre. Es la evolución moderna del histórico decorador @Input() y el equivalente conceptual de un atributo de directiva de AngularJS 1.x;
- output() declara una salida: un evento que el componente puede emitir hacia su padre (mediante el método .emit(value)). Es la evolución moderna de @Output() / EventEmitter y el equivalente de los eventos personalizados ($emit) de AngularJS 1.x.
5.6. Componentes independientes (standalone)
Una aplicación AngularJS 1.x se organizaba en módulos (angular.module(...)), que declaraban controladores, directivas y servicios. [Angular] adoptó primero esta idea de una forma más rígida (el NgModule, decorador @NgModule), antes de introducir, en versiones recientes, los componentes independientes (standalone), que desde entonces se han convertido en el modo de funcionamiento predeterminado.
Un componente standalone declara todo lo que necesita, como los demás componentes que usa en su plantilla, dentro de su propio decorador [@Component], en lugar de depender de un módulo compartido:
Este es el estilo que se usa en todo el cliente [RdvMedecins] (véase el capítulo siguiente): ya no aparece ningún archivo *.module.ts, una simplificación considerable tanto respecto de AngularJS 1.x como de las versiones anteriores de Angular.
5.7. Servicios e inyección de dependencias
Como en [NestJS] (Capítulo 2), un servicio de [Angular] es una clase ordinaria, decorada con [@Injectable], que [Angular] puede crear automáticamente y proporcionar a cualquier componente que la necesite; el mismo concepto de inyección de dependencias, principio que AngularJS 1.x fue, de hecho, uno de los primeros frameworks de JavaScript en popularizar (no es casualidad que [NestJS] se haya inspirado directamente en él, como se señaló en el Capítulo 2).
- Línea 3: providedIn: 'root' indica que se crea una única instancia de este servicio para toda la aplicación (un singleton); equivale a lo que era un .service() o un .factory() en AngularJS 1.x.
Para obtener este servicio en un componente, el [Angular] moderno ofrece la función inject(), que reemplaza la inyección tradicional por constructor (ambas siguen funcionando, pero inject() se ha convertido en la práctica estándar y es la que usa el cliente [RdvMedecins]):
5.8. Comunicación con el servidor: [HttpClient]
El módulo [HttpClient] ([@angular/common/http]) permite enviar solicitudes HTTP (GET, POST…) a un servidor y procesar su respuesta. Es una evolución directa del servicio $http de AngularJS 1.x que usaba el documento original.
Una diferencia importante respecto de $http: los métodos de [HttpClient] (get, post…) no devuelven directamente la respuesta, ni una Promise como podría esperarse, sino un Observable (biblioteca RxJS): un flujo de valores a lo largo del tiempo, al que uno se suscribe mediante .subscribe({ next, error }) para recibir una notificación cuando llega la respuesta (o se produce un error). También puede transformarse un Observable antes de suscribirse a él, mediante operadores como map:
El servicio [AppointmentService] del cliente [RdvMedecins] (próximo capítulo) usa de forma sistemática esta combinación .pipe(map(...)) por una razón específica que se explica allí.
5.9. La nueva sintaxis de control de flujo: [@if] y [@for]
AngularJS 1.x usaba directivas estructurales (ng-if, ng-repeat) para mostrar un elemento de forma condicional o repetir un bloque de plantilla por cada elemento de una lista. [Angular] utilizó durante mucho tiempo un equivalente muy parecido (*ngIf, *ngFor), antes de introducir, en sus versiones recientes, una sintaxis integrada en el propio lenguaje de plantillas, la que se usa en todo el cliente [RdvMedecins]:
- línea 8: track item.[id] (obligatorio con [@for]) indica a [Angular] cómo reconocer un elemento que ya se mostró cuando vuelve a dibujar la lista; algo muy parecido a “track by”, que ya era posible, de forma opcional, con ng-repeat.
5.10. Resumen: equivalencias AngularJS 1.x -> [Angular]
AngularJS 1.x (2014) | [Angular] (2026) |
Componente (clase + plantilla) | |
Signals (signal(), computed()) | |
Componentes standalone | |
input() / output() (signals) | |
[@Injectable]({ providedIn: 'root' }) | |
inject() (o siempre mediante el constructor) | |
[HttpClient] (Observables de RxJS) | |
[@if] / [@for] | |
TypeScript |
Estos antecedentes bastan para abordar el cliente [RdvMedecins] en el capítulo siguiente: no obstante, cada nueva característica se volverá a explicar allí, a medida que avance el código, en el punto exacto en que aparezca.