Skip to content

Angular Hoja de referencia

Framework de aplicaciones web basado en TypeScript, creado por Google.

01

Primeros pasos

Configuración de la CLI y creación de proyectos

La CLI de Angular es la herramienta principal de desarrollo. ng new genera un proyecto completo con enrutado y estilos preconfigurados. Usa ng generate (ng g) para crear archivos de forma consistente. La CLI se encarga de la compilación, las pruebas y el despliegue.

angular
# install Angular CLI globally
npm install -g @angular/cli

# create a new project
ng new my-app --routing --style=scss
cd my-app

# serve the app (default: localhost:4200)
ng serve --open

# generate components, services, etc.
ng generate component components/user-profile
ng g service services/auth
ng g module modules/admin --routing

Visión general de la estructura del proyecto

Angular impone una estructura de carpetas clara. src/app contiene el código completo de funcionalidades. main.ts arranca el componente raíz. angular.json configura las opciones de compilación, pruebas y servidor de desarrollo. La carpeta de environments permite cambiar las URLs de la API según el entorno.

angular
my-app/
├── src/
│   ├── app/                 # application code lives here
│   │   ├── app.component.ts
│   │   ├── app.component.html
│   │   └── app.config.ts    # standalone bootstrap config
│   ├── assets/              # static images, fonts
│   ├── environments/        # env-specific values
│   ├── index.html           # main HTML entry
│   ├── main.ts              # bootstrap entry point
│   └── styles.scss          # global styles
├── angular.json             # CLI workspace config
├── package.json
└── tsconfig.json

Servir y compilar

ng serve inicia un servidor de desarrollo con recarga estilo HMR en el puerto 4200 por defecto. Las compilaciones de producción aplican tree-shaking, minifican y añaden hash a los nombres de archivo para la caché. Usa --stats-json junto con webpack-bundle-analyzer para encontrar dependencias infladas. ng test ejecuta Karma por defecto.

angular
# dev server with live reload
ng serve --port 4300 --open

# production build (outputs to dist/)
ng build --configuration production

# analyze bundle size
ng build --stats-json
npx webpack-bundle-analyzer dist/my-app/stats.json

# run unit tests (Karma + Jasmine)
ng test

# run end-to-end tests
ng e2e

Generación de código (Schematics)

Los schematics garantizan un nombrado y un boilerplate consistentes. El flag --standalone genera componentes standalone (recomendado desde la v17). --route + --module conecta automáticamente una ruta con carga diferida. Los guards creados con --functional devuelven una función en lugar de una clase.

angular
# generate a standalone component
ng g component user-profile --standalone

# generate a service with root provider
ng g service services/auth

# generate a guard (functional by default)
ng g guard guards/auth --functional

# generate a pipe, directive, or module
ng g pipe pipes/shorten
ng g directive directives/highlight
ng g module admin --routing --route admin --module app

# generate an interface or enum
ng g interface models/user
ng g enum models/role

Configuración (angular.json)

angular.json es la configuración del workspace. Cada proyecto tiene los targets build, serve, test y lint. budgets avisa o da error cuando los bundles superan los umbrales. El array polyfills incluye zone.js, necesario para Angular. Varios proyectos (app + librería) pueden coexistir en un mismo workspace.

angular
{
  "projects": {
    "my-app": {
      "architect": {
        "build": {
          "options": {
            "outputPath": "dist/my-app",
            "index": "src/index.html",
            "main": "src/main.ts",
            "polyfills": ["zone.js"],
            "tsConfig": "tsconfig.app.json",
            "assets": ["src/favicon.ico", "src/assets"],
            "styles": ["src/styles.scss"],
            "scripts": []
          },
          "configurations": {
            "production": {
              "budgets": [{ "type": "initial", "maximumWarning": "500kb" }]
            }
          }
        }
      }
    }
  }
}

Entornos

Angular intercambia los archivos de entorno durante la compilación según la configuración (dev vs prod). Los reemplazos de archivos se configuran en angular.json bajo fileReplacements. Inyecta el objeto environment en cualquier lugar para acceder a valores específicos del entorno sin URLs fijas en el código. Nunca subas secretos reales al control de versiones.

angular
// src/environments/environment.ts
export const environment = {
  production: false,
  apiUrl: 'http://localhost:3000/api',
  apiKey: 'dev-key'
};

// src/environments/environment.prod.ts
export const environment = {
  production: true,
  apiUrl: 'https://api.example.com',
  apiKey: 'prod-key'
};

// usage in a service
import { environment } from '../environments/environment';

@Injectable({ providedIn: 'root' })
export class ApiService {
  private baseUrl = environment.apiUrl;
}
02

Fundamentos de componentes

Componente básico

Un componente es una clase de TypeScript decorada con @Component. selector es la etiqueta HTML personalizada que se usa en las plantillas. templateUrl/styleUrls apuntan a archivos externos; usa template/styles para las versiones en línea. @Input marca las propiedades a las que los componentes padre pueden enlazarse. Mantén los componentes enfocados en una sola responsabilidad.

angular
// user-profile.component.ts
import { Component, Input } from '@angular/core';

@Component({
  selector: 'app-user-profile',
  templateUrl: './user-profile.component.html',
  styleUrls: ['./user-profile.component.scss'],
})
export class UserProfileComponent {
  @Input() name = 'Guest';
  @Input() age = 0;

  greet() {
    return `Hello, ${this.name}!`;
  }
}

Componente con plantilla en línea

Las plantillas en línea son cómodas para componentes pequeños y evitan archivos extra. Usa backticks para cadenas multilínea — escapa los backticks internos con \`. styles acepta un array de cadenas CSS. El selector :host apunta al propio elemento del componente. Prefiere archivos externos cuando la plantilla supere unas 10 líneas.

angular
@Component({
  selector: 'app-counter',
  template: `
    <button (click)="decrement()">-</button>
    <span>{{ count }}</span>
    <button (click)="increment()">+</button>
  `,
  styles: [`
    :host { display: flex; gap: 8px; align-items: center; }
    button { padding: 4px 12px; }
  `],
})
export class CounterComponent {
  count = 0;
  increment() { this.count++; }
  decrement() { this.count--; }
}

Componente standalone (v14+)

Los componentes standalone no necesitan un NgModule — declaran su propio array imports que enumera las dependencias (CommonModule, FormsModule, otros componentes). Este es el enfoque moderno recomendado. Importa solo lo que uses para mejorar el tree-shaking. Arranca los componentes standalone directamente en main.ts.

angular
import { Component } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormsModule } from '@angular/forms';

@Component({
  selector: 'app-search',
  standalone: true,
  imports: [CommonModule, FormsModule],
  template: `
    <input [(ngModel)]="query" placeholder="Search..." />
    <p>Searching for: {{ query }}</p>
  `,
})
export class SearchComponent {
  query = '';
}

Inputs y outputs

@Input permite a los padres pasar datos mediante property bindings. @Output expone un EventEmitter al que los padres se suscriben mediante event bindings. Inicializa siempre los inputs con valores por defecto para evitar errores de undefined. Usa la nueva API de signals input()/output() para un código más limpio en v17+.

angular
@Component({
  selector: 'app-toggle',
  template: `
    <button (click)="toggle()">{{ label }}: {{ on ? 'On' : 'Off' }}</button>
  `,
})
export class ToggleComponent {
  @Input() label = 'Toggle';
  @Input() on = false;
  @Output() changed = new EventEmitter<boolean>();

  toggle() {
    this.on = !this.on;
    this.changed.emit(this.on);
  }
}

<!-- parent template -->
<app-toggle [label]="'Power'" [on]="isOn" (changed)="onToggle($event)" />

Inputs basados en signals (v17.1+)

La función input() crea un input de solo lectura basado en signals que se llama como una función. Soporta inputs obligatorios con input.required<T>(), transformaciones, y funciona a la perfección con computed() y effect(). output() es el reemplazo moderno de @Output EventEmitter. Este es el futuro de las APIs de componentes de Angular.

angular
import { Component, input, output } from '@angular/core';

@Component({
  selector: 'app-card',
  template: `
    <div>{{ title() }} - {{ count() }}</div>
    <button (click)="clicked.emit()">Click</button>
  `,
})
export class CardComponent {
  // readonly signal inputs with defaults
  title = input<string>('Default');
  count = input<number>(0);

  // output() function replaces @Output
  clicked = output<void>();

  // computed derived from inputs
  // requires import { computed }
  // label = computed(() => this.title().toUpperCase());
}

Encapsulación de vistas

Emulated (por defecto) añade atributos únicos para acotar los estilos al componente sin Shadow DOM real. None hace los estilos globales (úsalo con moderación). ShadowDom usa Shadow DOM nativo para un aislamiento verdadero, pero afecta a la penetración de estilos y a algunas librerías de terceros. Quédate con Emulated salvo que tengas necesidades concretas.

angular
@Component({
  selector: 'app-styles',
  template: `<p class="local">Emulated (default)</p>`,
  styles: [`p.local { color: red; }`],
  encapsulation: ViewEncapsulation.Emulated, // default
})
export class StylesComponent {}

// ViewEncapsulation.None    -> styles leak globally
// ViewEncapsulation.ShadowDom -> real Shadow DOM (strong isolation)
// ViewEncapsulation.Emulated -> scoped attributes (default, recommended)
03

Sintaxis de plantillas

Interpolación de texto

Las llaves dobles {{ }} renderizan expresiones como texto, con escape HTML. Puedes usar la mayoría de expresiones de JS: aritmética, ternarios, llamadas a métodos, acceso a propiedades. No hay new, typeof ni operadores de asignación. Los pipes (|) transforman la salida. La interpolación se reevalúa en cada ciclo de detección de cambios.

angular
<p>{{ title }}</p>                       <!-- renders the value -->
<p>{{ 1 + 2 }}</p>                        <!-- expressions allowed -->
<p>{{ user.name }}</p>                    <!-- property access -->
<p>{{ items.length }}</p>                 <!-- method/property -->
<p>{{ price | currency:'USD' }}</p>       <!-- pipe in interpolation -->
<p>{{ isReady ? 'Yes' : 'No' }}</p>       <!-- ternary -->

<!-- one-time interpolation updates when the source changes -->
<!-- new control flow @if, @for work without *ngIf/*ngFor directives -->

Enlace de propiedades y atributos

[prop] enlaza a una propiedad del DOM (preferido). [attr.name] enlaza a atributos HTML para casos sin propiedad DOM correspondiente (colspan, atributos SVG). [class.x] activa o desactiva una clase según su valor de verdad; [style.prop] fija un estilo, con sufijo de unidad opcional como .px o %. Evita enlazar innerHTML con contenido no confiable.

angular
<!-- property binding: [prop]="expression" -->
<img [src]="user.avatar" [alt]="user.name" />
<button [disabled]="isSaving">Save</button>
<my-comp [data]="items"></my-comp>

<!-- attribute binding (for attrs without DOM props) -->
<td [attr.colspan]="2">Merged cell</td>
<svg [attr.viewBox]="box"></svg>

<!-- class & style binding -->
<div [class.active]="isActive">Active?</div>
<div [class]="dynamicClassString">
<div [style.color]="colorVar">
<div [style.width.px]="size">Width</div>

Enlace de eventos

(event) enlaza a eventos del DOM y a outputs personalizados de EventEmitter. $event es el payload del evento (un DOM Event para eventos nativos, el valor emitido para los personalizados). Los modificadores de eventos como .enter, .esc, .prevent, .stop filtran o transforman eventos. El objetivo entre paréntesis determina qué dispara el manejador.

angular
<button (click)="save()">Save</button>
<input (input)="onInput($event)" (keyup)="onKey($event)" />
<div (mouseenter)="hover=true" (mouseleave)="hover=false">Hover</div>

<!-- $event is the DOM event object -->
<input (keyup.enter)="submit()" (keyup.esc)="cancel()" />

<!-- passive events (scroll, touchmove) -->
<div (scroll.passive)="onScroll($event)">...</div>

<!-- binding to custom component outputs -->
<app-child (changed)="onChanged($event)"></app-child>

Variables de referencia de plantilla

Una #var (o ref-var) referencia el elemento del DOM o la instancia de componente donde se declara. Es accesible en cualquier parte de la plantilla. Para componentes, el valor es la instancia del componente; para elementos, es el HTMLElement. Dentro de @for, $index, $first, $last, $even y $odd son variables de contexto implícitas.

angular
<input #nameInput type="text" />
<button (click)="nameInput.focus()">Focus</button>
<p>You typed: {{ nameInput.value }}</p>

<!-- ref to a component instance -->
<app-form #f="appForm"></app-form>
<button [disabled]="!f.valid" (click)="f.submit()">Submit</button>

<!-- ref inside @for -->
<ul>
  @for (item of items; track item.id) {
    <li>{{ item.name }} (index: {{ $index }})</li>
  }
</ul>

Enlace bidireccional (banana in a box)

[(ngModel)] requiere FormsModule. La sintaxis [(x)] es azúcar para [x] + (xChange), así que los enlaces bidireccionales personalizados necesitan un input llamado x y un output llamado xChange. Recuerda el mnemotécnico 'banana in a box' — los paréntesis van dentro de los corchetes. La función de signal model() simplifica esto en v17.2+.

angular
<!-- [()] = "banana in a box" - property + event combined -->
<input [(ngModel)]="username" />

<!-- equivalent to -->
<input [ngModel]="username" (ngModelChange)="username = $event" />

<!-- two-way binding on custom components -->
<app-counter [(value)]="count"></app-counter>
<!-- requires: @Input() value; @Output() valueChange = new EventEmitter() -->

<!-- signals: model() for two-way (v17.2+) -->
// value = model<number>(0);

Navegación segura y aserción de no nulo

El operador ?. navega con seguridad por cadenas de valores nulos, devolviendo undefined en lugar de lanzar un error. Úsalo con datos asíncronos que aún no se han cargado. El operador ! es solo una aserción en tiempo de compilación — no añade comprobaciones en tiempo de ejecución, así que úsalo solo cuando estés seguro. Para arrays que pueden ser nulos, usa ?? [] como respaldo.

angular
<!-- safe navigation: short-circuits to undefined if null -->
<p>{{ user?.profile?.bio }}</p>
<p>{{ user?.getName?.() }}</p>

<!-- non-null assertion: tells compiler it's not null -->
<p>{{ user!.name }}</p>

<!-- in property bindings -->
<img [src]="user?.avatar" />
<app-detail [data]="user!"></app-detail>

<!-- safe navigation in @for doesn't replace track -->
@for (item of items ?? []; track item.id) { ... }
04

Directivas

@if / @else (nuevo control de flujo)

La nueva sintaxis de bloques @if/@else if/@else reemplaza a *ngIf. No hace falta importar CommonModule ni NgIf, no hay asterisco, y @else funciona de forma nativa (a diferencia del truco con ng-template de ngIf). Es la sintaxis recomendada para código nuevo. Forma parte del control de flujo integrado introducido en v17 y estable en v18.

angular
@if (user) {
  <p>Hello, {{ user.name }}</p>
} @else if (loading) {
  <p>Loading...</p>
} @else {
  <p>No user found.</p>
}

<!-- no structural directive import needed, no * prefix -->
<!-- works in standalone templates automatically (v17+) -->

@for / @empty (nuevo control de flujo)

@for reemplaza a *ngFor con una expresión track obligatoria para un diffing eficiente del DOM. @empty renderiza contenido alternativo cuando la colección está vacía. Las variables de contexto implícitas ($index, $first, $last, etc.) están siempre disponibles. El tracking por un id único y estable es clave para el rendimiento con listas grandes.

angular
<ul>
  @for (item of items; track item.id) {
    <li>{{ item.name }} ({{ $index }})</li>
  } @empty {
    <li>No items yet.</li>
  }
</ul>

<!-- 'track' is REQUIRED for performance -->
<!-- implicit vars: $index, $first, $last, $even, $odd, $count -->

<!-- @for over a range -->
@for (i of [1,2,3,4,5]; track i) {
  <span>{{ i }}</span>
}

ngClass y ngStyle

ngClass acepta un objeto (se aplican las claves verdaderas), un array o una cadena. ngStyle acepta un objeto con claves en camelCase o kebab-case, con sufijos de unidad opcionales. Requiere importar CommonModule o las directivas específicas. Para una sola clase/estilo, [class.x] y [style.x] son más ligeros y no necesitan importaciones.

angular
<div [ngClass]="{ active: isActive, disabled: !enabled }">Box</div>
<div [ngClass]="['card', 'shadow', themeClass]">Card</div>
<div [ngClass]="currentClass">String</div>

<div [ngStyle]="{ color: textColor, 'font-size.px': size }">Text</div>
<div [ngStyle]="styleObject">Styled</div>

<!-- import CommonModule (or NgClass/NgStyle) for these -->
<!-- prefer [class.x] and [style.x] for single value bindings -->

@switch (nuevo control de flujo)

@switch reemplaza a *ngSwitch (y a las directivas ngSwitchCase/ngSwitchDefault). Es más limpio — no hace falta un contenedor envolvente ni importaciones. Cada @case se renderiza solo cuando su valor coincide con la expresión del @switch. @default es el caso por defecto. Es el control de flujo integrado disponible en v17+.

angular
@switch (status) {
  @case ('loading') {
    <spinner>Loading...</spinner>
  }
  @case ('error') {
    <p class="error">Something went wrong</p>
  }
  @case ('success') {
    <p>Done!</p>
  }
  @default {
    <p>Idle</p>
  }
}

Directiva de atributo personalizada

Las directivas de atributo cambian la apariencia o el comportamiento de los elementos del DOM. Los [corchetes] del selector coinciden con el uso como atributo. ElementRef da acceso directo al DOM; HostListener se enlaza a eventos del DOM. Inyecta ElementRef<HTMLElement> para tener seguridad de tipos. Prefiere Renderer2 para manipular el DOM en escenarios de renderizado en el servidor.

angular
import { Directive, ElementRef, Input, HostListener } from '@angular/core';

@Directive({
  selector: '[appHighlight]',
})
export class HighlightDirective {
  @Input('appHighlight') highlightColor = 'yellow';

  constructor(private el: ElementRef<HTMLElement>) {}

  @HostListener('mouseenter') onMouseEnter() {
    this.el.nativeElement.style.backgroundColor = this.highlightColor;
  }

  @HostListener('mouseleave') onMouseLeave() {
    this.el.nativeElement.style.backgroundColor = '';
  }
}

<!-- usage: <p appHighlight="lightblue">Hover me</p> -->

Interioridades de las directivas estructurales

Las directivas estructurales añaden o quitan nodos del DOM mediante TemplateRef (la plantilla envuelta) y ViewContainerRef (dónde insertarla). El asterisco (*) es azúcar que envuelve el elemento en un <ng-template>. Los nuevos bloques @if/@for/@switch reemplazan la mayoría de directivas estructurales personalizadas, pero este patrón sigue siendo útil en casos avanzados.

angular
import { Directive, TemplateRef, ViewContainerRef, Input } from '@angular/core';

@Directive({ selector: '[appUnless]' })
export class UnlessDirective {
  private hasView = false;

  @Input() set appUnless(condition: boolean) {
    if (!condition && !this.hasView) {
      this.vc.createEmbeddedView(this.tpl);
      this.hasView = true;
    } else if (condition && this.hasView) {
      this.vc.clear();
      this.hasView = false;
    }
  }

  constructor(private tpl: TemplateRef<unknown>, private vc: ViewContainerRef) {}
}

<!-- usage: <div *appUnless="hide">Shown when hide is false</div> -->
05

Pipes

Pipes integrados

Los pipes transforman los valores que se muestran en la plantilla. Los integrados más comunes: date, number, currency, percent, uppercase, lowercase, titlecase, slice, json, async. Los pipes son puros por defecto — solo se recalculan cuando cambia la referencia del input. Las cadenas de formato siguen las reglas de localización de Angular.

angular
<!-- date formatting -->
<p>{{ today | date }}</p>                          <!-- Sep 10, 2024 -->
<p>{{ today | date:'short' }}</p>
<p>{{ today | date:'yyyy-MM-dd HH:mm' }}</p>

<!-- number & currency -->
<p>{{ 3.14159 | number:'1.2-2' }}</p>               <!-- 3.14 -->
<p>{{ price | currency:'USD':'symbol':'1.2-2' }}</p>
<p>{{ ratio | percent }}</p>

<!-- text transforms -->
<p>{{ 'hello world' | uppercase }}</p>              <!-- HELLO WORLD -->
<p>{{ 'HELLO' | lowercase }}</p>
<p>{{ title | titlecase }}</p>
<p>{{ 'a/b/c' | slice:0:2 }}</p>

<!-- json (for debugging) -->
<pre>{{ obj | json }}</pre>

Encadenar pipes y parámetros

Los pipes se encadenan de izquierda a derecha, y cada uno recibe la salida del anterior. Los parámetros se separan con dos puntos y son posicionales. Úsalos para transformaciones puras (formateo, filtrado) y así mantener las plantillas declarativas. Evita los pipes impuros con datos sensibles al rendimiento; calcula en el componente en su lugar.

angular
<!-- chain: left to right, output of one feeds the next -->
<p>{{ '  hello  ' | trim | uppercase }}</p>         <!-- HELLO -->
<p>{{ birthday | date:'fullDate' | uppercase }}</p>
<p>{{ items | slice:0:3 | json }}</p>

<!-- parameters separated by colons -->
<p>{{ amount | number:'1.2-2':'en-US' }}</p>
<p>{{ meeting | date:'shortTime' }}</p>
<p>{{ list | slice:1:5 }}</p>

<!-- multiple parameters -->
<p>{{ value | myPipe:arg1:arg2:arg3 }}</p>

Pipe personalizado

Los pipes personalizados implementan PipeTransform.transform(). El nombre del @Pipe se usa en las plantillas. Registra los pipes standalone (v15+) en el array imports del componente, o decláralos en un NgModule. Los pipes puros (por defecto) solo se vuelven a ejecutar cuando cambia la referencia del input — pasa nuevas referencias para disparar las actualizaciones.

angular
import { Pipe, PipeTransform } from '@angular/core';

@Pipe({ name: 'truncate' })
export class TruncatePipe implements PipeTransform {
  transform(value: string, limit = 20, ellipsis = '...'): string {
    if (!value) return '';
    return value.length > limit
      ? value.slice(0, limit) + ellipsis
      : value;
  }
}

// register in a standalone component imports:
// imports: [TruncatePipe]

<!-- usage -->
<p>{{ longText | truncate:50 }}</p>
<p>{{ longText | truncate:10:'>>' }}</p>

Pipe async

El pipe async se suscribe a un Observable o Promise, renderiza el valor y se desuscribe automáticamente al destruirse — sin necesidad de subscribe/unsubscribe manual. Combinado con *ngIf as o @for, maneja con elegancia los valores nulos durante la carga. Marca el componente para comprobación cuando llega un nuevo valor, integrándose con OnPush.

angular
@Component({
  selector: 'app-user',
  template: `
    <div *ngIf="user$ | async as user">
      {{ user.name }}
    </div>
    <ul>
      @for (item of items$ | async; track item.id) {
        <li>{{ item.name }}</li>
      }
    </ul>
  `,
  imports: [AsyncPipe, NgIf],
})
export class UserComponent {
  user$ = this.http.get<User>('/api/user');
  items$ = this.http.get<Item[]>('/api/items');

  constructor(private http: HttpClient) {}
}

Pipes puros vs impuros

Los pipes puros almacenan en caché los resultados hasta que cambia la referencia del input; mutar arrays u objetos no los dispara. Los pipes impuros (pure: false) se ejecutan en cada detección de cambios — cómodos para filtrar arrays mutados, pero costosos. Prefiere mantener los datos inmutables (reemplaza arrays en vez de mutarlos) y usa pipes puros por rendimiento.

angular
// PURE (default): re-runs only when input reference changes
@Pipe({ name: 'filter' })
export class FilterPipe implements PipeTransform {
  transform(items: Item[], term: string): Item[] {
    return items.filter(i => i.name.includes(term));
  }
}
// Issue: mutating items.push() won't trigger re-evaluation.

// IMPURE: re-runs on every change detection cycle
@Pipe({ name: 'filter', pure: false })
export class ImpureFilterPipe implements PipeTransform { ... }
// ⚠️ Expensive! Use sparingly — affects performance.

Pipes i18n y de localización

Pipes como date, number y currency respetan LOCALE_ID. Registra los datos de locale con registerLocaleData antes del bootstrap. Los formatos de moneda/decimales siguen el locale activo. Para apps multilingües, proporciona LOCALE_ID por usuario o usa las herramientas i18n para traducir plantillas. Si faltan datos de locale, se recurre a en-US.

angular
// register locale data in app.config.ts
import { registerLocaleData } from '@angular/common';
import localeFr from '@angular/common/locales/fr';
registerLocaleData(localeFr);

// provide a default locale
providers: [{ provide: LOCALE_ID, useValue: 'fr-FR' }]

// usage - now locale-aware
<p>{{ price | currency:'EUR' }}</p>          <!-- 1 234,56 € -->
<p>{{ today | date:'fullDate' }}</p>          <!-- lundi 10 septembre 2024 -->
<p>{{ number | number:'1.2-2' }}</p>          <!-- 1 234,56 -->
<p>{{ amount | currency:'JPY' }}</p>          <!-- ¥1,235 -->
06

Servicios e inyección de dependencias

Servicio básico

providedIn: 'root' crea un singleton disponible en toda la app sin registro en módulos. El servicio es tree-shakeable — se elimina si no se usa. Usa la función inject() (v14+) en lugar de la inyección por constructor para un código más limpio y pruebas más fáciles. Los servicios guardan el estado compartido y la lógica de negocio; los componentes se mantienen presentacionales.

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

@Injectable({ providedIn: 'root' })
export class UserService {
  private users = ['Alice', 'Bob'];

  getUsers() { return this.users; }
  addUser(name: string) { this.users.push(name); }
}

// usage in a component
export class UserListComponent {
  // Angular injects the singleton instance
  constructor(private users: UserService) {}

  get users() { return this.usersService.getUsers(); }
  private usersService = inject(UserService);
}

Función inject()

inject() es la alternativa moderna a la inyección por constructor. Funciona en inicializadores de campos, lo que hace el código más legible y permite una mejor inferencia de TypeScript. Debe ejecutarse durante la construcción (no en callbacks asíncronos posteriores). Úsalo de forma consistente — mezclar parámetros de constructor e inject() es válido, pero inject() es más limpio.

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

@Injectable({ providedIn: 'root' })
export class AuthService {
  private http = inject(HttpClient);
  private router = inject(Router);

  login(creds: Credentials) {
    return this.http.post('/api/login', creds);
  }
}

// in a component
export class DashboardComponent {
  private auth = inject(AuthService);
  user = this.auth.currentUser;   // works in field initializers
}

Configuración de providers

Los providers se pueden configurar en cualquier nivel (root, módulo, componente). useClass intercambia implementaciones (ideal para mocks). useValue proporciona constantes. useExisting crea un alias de un servicio a otro. useFactory crea instancias dinámicamente. InjectionToken sirve para valores que no son clases, como cadenas u objetos de configuración.

angular
@Component({
  // ... provide at component level for instance-per-component
  providers: [
    UserService,                              // shorthand
    { provide: Logger, useClass: ConsoleLogger },
    { provide: API_URL, useValue: 'https://api.example.com' },
    { provide: Storage, useExisting: LocalStorageService },
    {
      provide: Config,
      useFactory: () => new Config(env.production)
    },
  ],
})
export class AdminComponent {}

// InjectionToken for non-class values
export const API_URL = new InjectionToken<string>('API_URL');

Inyectores jerárquicos

El árbol de DI de Angular refleja el árbol de componentes. providedIn: 'root' = una instancia en toda la app. Los providers a nivel de componente crean inyectores hijos — cada instancia obtiene el suyo. Esto es útil para componentes con estado, como editores. 'any' limita el ámbito a los módulos lazy. 'platform' es poco común, se usa en configuraciones multi-app.

angular
// root injector (singleton app-wide)
@Injectable({ providedIn: 'root' })
export class AuthService {}

// component-level provider: new instance for this component and children
@Component({
  providers: [UserService],   // each AdminComponent gets its own UserService
})
export class AdminComponent {}

// 'any' creates a lazy singleton per lazy module
@Injectable({ providedIn: 'any' })
export class SharedService {}

// 'platform' shared across all Angular apps on the page
@Injectable({ providedIn: 'platform' })
export class GlobalConfig {}

Multi providers y tokens

multi: true registra varios providers bajo un mismo token, inyectados como un array. Útil para sistemas de plugins, interceptores, validadores o cualquier colección extensible. El orden de inyección sigue el orden de registro. Combínalo con InjectionToken para tipar bien el array.

angular
// define a token for a list of plugins
export const PLUGIN = new InjectionToken<Plugin>('PLUGIN');

// provide multiple plugins
@Component({
  providers: [
    { provide: PLUGIN, useClass: AuthPlugin, multi: true },
    { provide: PLUGIN, useClass: AnalyticsPlugin, multi: true },
  ],
})
export class AppComponent {}

// inject all of them as an array
export class PluginManager {
  plugins = inject(PLUGIN);   // Plugin[]
}

Providers opcionales y por defecto

@Optional() o inject(token, { optional: true }) devuelve null si no se encuentra ningún provider en lugar de lanzar un error. Úsalo para dependencias no críticas. Otros modificadores: @SkipSelf() (no revisar el inyector actual), @Self() (solo el actual), @Host() (hasta el componente host). Los equivalentes de inject() aceptan flags en el objeto de opciones.

angular
import { Injectable, inject, Optional, Inject } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class Logger {
  constructor(@Optional() @Inject(CONFIG) private cfg?: Config) {
    // cfg is null if no provider exists — handle gracefully
  }
}

// or with inject()
export class Service {
  cfg = inject(CONFIG, { optional: true });   // Config | null
  baseUrl = inject(API_URL, { optional: true }) ?? '/api';
}

// skipSelf: look in parent injectors only
// self: only this component's injector
// host: limit to host component
07

Enrutado

Configuración de rutas

Las rutas mapean rutas URL a componentes. loadComponent/loadChildren habilitan la carga diferida (bundle inicial más pequeño). :id es un parámetro de ruta. El comodín '**' captura las URLs sin coincidencia — colócalo al final. provideRouter configura el router en apps standalone. Define title para los nombres de pestaña del navegador; puede ser una cadena o un ResolveFn.

angular
// app.routes.ts (standalone)
import { Routes } from '@angular/router';

export const routes: Routes = [
  { path: '', component: HomeComponent, title: 'Home' },
  { path: 'about', loadComponent: () => import('./about/about.component')
      .then(m => m.AboutComponent) },
  { path: 'users/:id', component: UserDetailComponent },
  { path: 'admin', loadChildren: () => import('./admin/admin.routes')
      .then(m => m.ADMIN_ROUTES) },
  { path: '**', component: NotFoundComponent },   // wildcard
];

// app.config.ts
export const appConfig: ApplicationConfig = {
  providers: [provideRouter(routes)]
};

Router outlet y enlaces

router-outlet marca dónde se renderizan los componentes enrutados. routerLink crea enlaces de navegación (usa la forma de array para parámetros). routerLinkActive aplica una clase cuando la ruta coincide. La navegación programática usa router.navigate() o routerLink. Los outlets con nombre permiten rutas secundarias (por ejemplo, un modal junto a la vista principal).

angular
<!-- app.component.html -->
<nav>
  <a routerLink="/" routerLinkActive="active">Home</a>
  <a routerLink="/about" routerLinkActive="active">About</a>
  <a [routerLink]="['/users', userId]">My Profile</a>
</nav>

<router-outlet></router-outlet>

<!-- named outlet (secondary route) -->
<router-outlet name="popup"></router-outlet>

<!-- navigate programmatically -->
<button (click)="go()">Go</button>
// constructor(private router: Router) {}
// go() { this.router.navigate(['/users', 42]); }

Parámetros de ruta y query params

Usa snapshot para lecturas únicas cuando el componente se destruye y se recrea en cada navegación. Usa los observables paramMap/queryParamMap cuando la misma instancia de componente maneja parámetros distintos (por ejemplo, navegar de /users/1 a /users/2). Desuscríbete siempre o usa el pipe async para evitar fugas.

angular
// reading route params
export class UserDetailComponent {
  constructor(private route: ActivatedRoute) {
    // snapshot: one-time read (good for static links)
    const id = this.route.snapshot.paramMap.get('id');

    // observable: reacts to param changes (same component reused)
    this.route.paramMap.subscribe(params => {
      console.log(params.get('id'));
    });
  }
}

// query params: /search?q=angular&page=2
this.route.queryParamMap.subscribe(qp => {
  this.q = qp.get('q');
});

<!-- link with query params -->
<a [routerLink]="['/search']" [queryParams]="{ q: 'angular', page: 2 }">

Rutas hijas y anidadas

Las rutas hijas se renderizan en un router-outlet anidado dentro del componente padre. redirectTo con pathMatch: 'full' redirige las rutas hijas vacías. Este patrón construye diseños maestro-detalle (estructura del padre, contenido del hijo). Cada nivel de anidamiento necesita su propio router-outlet en la plantilla del padre.

angular
export const routes: Routes = [
  {
    path: 'admin',
    component: AdminLayoutComponent,
    children: [
      { path: '', redirectTo: 'dashboard', pathMatch: 'full' },
      { path: 'dashboard', component: DashboardComponent },
      { path: 'users', component: AdminUsersComponent },
      { path: 'settings', component: SettingsComponent },
    ],
  },
];

<!-- AdminLayoutComponent template -->
<h2>Admin Panel</h2>
<nav>...</nav>
<router-outlet></router-outlet>   <!-- child routes render here -->

Carga diferida (lazy loading)

La carga diferida divide la app en chunks que se cargan bajo demanda, reduciendo el bundle inicial. loadChildren carga un archivo de rutas (exportación por defecto de Routes); loadComponent carga un único componente standalone. La cadena del import() dinámico debe ser una ruta estática para que el bundler pueda dividir correctamente. Úsalo para áreas de funcionalidad tras la navegación.

angular
// main routes - load feature modules on demand
export const routes: Routes = [
  { path: '', component: HomeComponent },
  {
    path: 'admin',
    loadChildren: () => import('./admin/admin.routes').then(m => m.ADMIN_ROUTES),
  },
  {
    path: 'reports',
    loadComponent: () => import('./reports/reports.component')
      .then(m => m.ReportsComponent),
  },
];

// admin.routes.ts
export const ADMIN_ROUTES: Routes = [
  { path: '', component: AdminComponent },
  { path: 'users', component: AdminUsersComponent },
];

Eventos del router y navegación

Los eventos del router (NavigationStart, NavigationEnd, GuardsCheckStart, etc.) permiten seguir el ciclo de vida de la navegación. Filtra siempre por eventos concretos y desuscríbete. router.navigate acepta extras: queryParams, fragment, state (datos transitorios que no van en la URL) y replaceUrl. state se lee mediante router.getCurrentNavigation().extras.state.

angular
// subscribe to router events
export class AppComponent implements OnDestroy {
  private sub = this.router.events.pipe(
    filter((e): e is NavigationEnd => e instanceof NavigationEnd)
  ).subscribe(e => {
    console.log('Navigated to:', e.url);
    this.analytics.track(e.url);
  });

  constructor(private router: Router) {}
  ngOnDestroy() { this.sub.unsubscribe(); }
}

// navigation with extras
this.router.navigate(['/users'], {
  queryParams: { sort: 'name' },
  fragment: 'top',
  state: { from: 'login' },   // passed to next route, not in URL
});
08

Formularios

Formulario basado en plantilla (template-driven)

Los formularios template-driven usan ngModel y referencias de plantilla. Se requiere FormsModule. El estado del formulario (validez, touched, dirty) se sigue mediante las directivas ngForm y ngModel. Ideal para formularios simples. La validación se declara en la plantilla (required, minlength, pattern). Accede al estado del control mediante referencias de plantilla como #e='ngModel'.

angular
import { FormsModule } from '@angular/forms';

@Component({
  selector: 'app-login',
  standalone: true,
  imports: [FormsModule],
  template: `
    <form #f="ngForm" (ngSubmit)="save(f.value)">
      <input name="email" [(ngModel)]="email" required email #e="ngModel" />
      <span *ngIf="e.invalid && e.touched">Email required</span>

      <input name="pwd" type="password" [(ngModel)]="pwd" required minlength="6" />
      <button [disabled]="f.invalid">Submit</button>
    </form>
  `,
})
export class LoginComponent {
  email = '';
  pwd = '';
  save(v: any) { console.log(v); }
}

Configuración de formularios reactivos

Los formularios reactivos definen el modelo en la clase del componente como instancias de FormControl/FormGroup. Se requiere ReactiveFormsModule. formControlName enlaza los inputs a los controles. El modelo del formulario es observable y testeable sin el DOM. nonNullable: true evita valores nulos cuando se limpia el input. Preferido para formularios complejos.

angular
import { ReactiveFormsModule, FormControl, FormGroup } from '@angular/forms';

@Component({
  selector: 'app-profile',
  imports: [ReactiveFormsModule],
  template: `
    <form [formGroup]="form" (ngSubmit)="save()">
      <input formControlName="name" />
      <input formControlName="email" />
      <button [disabled]="form.invalid">Save</button>
    </form>
    <p>Valid: {{ form.valid }}</p>
  `,
})
export class ProfileComponent {
  form = new FormGroup({
    name: new FormControl('', { nonNullable: true }),
    email: new FormControl('', { nonNullable: true }),
  });
  save() { console.log(this.form.value); }
}

FormBuilder y formularios tipados

FormBuilder reduce el boilerplate. fb.group() infiere los tipos a partir de los valores por defecto. Los grupos anidados modelan datos anidados. FormArray gestiona listas dinámicas de controles. Con nonNullable, los controles mantienen su tipo declarado en lugar de null. Usa get() o controls para un acceso con seguridad de tipos. Los formularios tipados (v14+) te dan autocompletado y comprobación de tipos en value.

angular
import { FormBuilder, FormGroup } from '@angular/forms';

export class CheckoutComponent {
  private fb = inject(FormBuilder);

  // typed form (v14+ nonNullable)
  form = this.fb.group({
    name: ['', { nonNullable: true }],
    address: this.fb.group({
      street: [''],
      city: [''],
      zip: [''],
    }),
    items: this.fb.array<CartItem>([]),
  });

  // type-safe access
  get items() { return this.form.controls.items; }
  addItem(item: CartItem) { this.items.push(this.fb.control(item)); }
}

Validación de formularios

Validators.required, .minLength, .maxLength, .pattern, .email, .min y .max son los integrados. Aplica varios mediante un array. La validación entre campos vive en el FormGroup con una función validadora que recibe el grupo completo. Comprueba control.touched/dirty antes de mostrar errores para no regañar al usuario en el primer render. Usa .hasError('key') para comprobar errores concretos.

angular
import { Validators } from '@angular/forms';

// built-in validators
const email = new FormControl('', [
  Validators.required,
  Validators.email,
  Validators.maxLength(100),
]);

const password = new FormControl('', [
  Validators.required,
  Validators.minLength(8),
  Validators.pattern(/[A-Z]/),
]);

// cross-field validation at group level
const form = this.fb.group({
  pwd: ['', Validators.required],
  confirm: ['', Validators.required],
}, { validators: matchPassword });   // custom group validator

// reading state in template
<!-- <span *ngIf="email.touched && email.hasError('required')">Required</span> -->

Validador personalizado

Los validadores personalizados son funciones que devuelven ValidationErrors (un mapa) o null si es válido. Los validadores asíncronos devuelven un Observable o Promise — úsalos para comprobaciones del servidor, como la disponibilidad de un nombre de usuario. Aplica siempre debounce a los validadores asíncronos (con timer/switchMap) para no saturar el servidor con cada pulsación.

angular
import { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';

// function validator
export const matchPassword: ValidatorFn = (group: AbstractControl): ValidationErrors | null => {
  const pwd = group.get('pwd')?.value;
  const confirm = group.get('confirm')?.value;
  return pwd === confirm ? null : { mismatch: true };
};

// async validator (returns Observable/Promise)
export function uniqueUsername(http: HttpClient): AsyncValidatorFn {
  return (control: AbstractControl) => {
    return timer(500).pipe(
      switchMap(() => http.get(`/api/check/${control.value}`)),
      map(exists => exists ? { taken: true } : null),
    );
  };
}

Cambios de valor y estado del formulario

valueChanges y statusChanges son Observables que emiten en cada input. debounceTime evita trabajo excesivo al escribir rápido. takeUntil con un Subject es la forma idiomática de desuscribirse al destruir. patchValue actualiza valores parciales del formulario; setValue exige cada campo. Usa { emitEvent: false } para actualizar en silencio sin disparar valueChanges.

angular
export class FilterComponent implements OnDestroy {
  private destroy = new Subject<void>();
  form = this.fb.group({ q: [''], category: ['all'] });

  ngOnInit() {
    // react to entire form changes (debounced)
    this.form.valueChanges.pipe(
      debounceTime(300),
      takeUntil(this.destroy),
    ).subscribe(v => this.search(v));

    // react to a single control
    this.form.controls.q.valueChanges.subscribe(q => {
      console.log('q changed:', q);
    });
  }

  ngOnDestroy() { this.destroy.next(); }
}
09

HttpClient

Configuración y GET básico

provideHttpClient() registra el cliente en toda la app. Las funciones de HttpClient devuelven Observables fríos — solo se ejecutan al suscribirse (usa el pipe async en las plantillas o subscribe en los servicios). Las respuestas se tipan mediante genéricos. Gestiona siempre los errores de forma centralizada o por llamada. withFetch() (v18) activa el backend moderno basado en fetch.

angular
// app.config.ts
import { provideHttpClient } from '@angular/common/http';

export const appConfig: ApplicationConfig = {
  providers: [provideHttpClient()],
};

// usage in a service
@Injectable({ providedIn: 'root' })
export class PostService {
  private http = inject(HttpClient);
  private api = 'https://jsonplaceholder.typicode.com/posts';

  getPosts() {
    return this.http.get<Post[]>(this.api);
  }
}

// in a component (use async pipe to auto-unsubscribe)
export class PostListComponent {
  posts$ = this.posts.getPosts();
  constructor(private posts: PostService) {}
}

POST / PUT / DELETE

post/put/patch devuelven Observables que emiten la respuesta una vez y luego se completan. Pasa el body como segundo argumento. El tipo genérico acota la respuesta. La URL puede ser un template literal con parámetros. Suscríbete siempre — los Observables son fríos y no se disparan si no. Considera toPromise() (obsoleto) o firstValueFrom() para lecturas de un solo uso.

angular
export class PostService {
  private http = inject(HttpClient);

  create(post: Omit<Post, 'id'>) {
    return this.http.post<Post>('/api/posts', post);
  }

  update(id: number, patch: Partial<Post>) {
    return this.http.put<Post>(`/api/posts/${id}`, patch);
  }

  remove(id: number) {
    return this.http.delete<void>(`/api/posts/${id}`);
  }
}

// all return Observables — subscribe or use async pipe
// HTTP methods return a single value then complete

Query parameters y headers

params acepta un objeto, HttpParams o un array — Angular los codifica en la query string. headers define las cabeceras de la petición. observe: 'response' devuelve la HttpResponse completa (status, headers, body) en lugar de solo el body. observe: 'events' con reportProgress emite eventos de progreso para subidas/descargas de archivos.

angular
export class SearchService {
  private http = inject(HttpClient);

  search(term: string, page = 1) {
    return this.http.get<Result[]>('/api/search', {
      params: { q: term, page, sort: 'desc' },
      headers: { 'X-Api-Key': 'secret' },
      observe: 'response',   // get full HttpResponse
      responseType: 'json',
    });
  }

  // observe: 'events' streams upload/download progress
  upload(file: File) {
    return this.http.post('/api/upload', file, {
      reportProgress: true,
      observe: 'events',
    });
  }
}

Interceptores

Los interceptores funcionales (v15+) son funciones simples encadenadas mediante withInterceptors(). Se ejecutan en orden para cada petición, perfectos para tokens de autenticación, logging, lógica de reintento o caché. clone() crea una petición modificada (las peticiones son inmutables). La función next(req) devuelve el stream de respuesta — aquí aplican operadores de pipe como retry y catchError.

angular
// functional interceptor (v15+)
export const authInterceptor: HttpInterceptorFn = (req, next) => {
  const token = localStorage.getItem('token');
  const authReq = token
    ? req.clone({ setHeaders: { Authorization: `Bearer ${token}` } })
    : req;
  return next(authReq);
};

// register in app.config.ts
providers: [provideHttpClient(withInterceptors([authInterceptor]))]

// error/logging interceptor
export const loggingInterceptor: HttpInterceptorFn = (req, next) => {
  console.log('Request:', req.url);
  return next(req).pipe(tap({
    error: e => console.error('Failed:', req.url, e),
  }));
};

Gestión de errores

Usa operadores de RxJS para la resiliencia HTTP: retry vuelve a suscribirse ante un error, timeout aborta las peticiones lentas, catchError mapea los errores a valores alternativos o los relanza. Gestiona también los errores en el lado del consumidor — los errores de Observable no capturados detienen el stream. Suscríbete con los callbacks next/error/complete para manejar el ciclo de vida completo.

angular
export class PostService {
  getPost(id: number) {
    return this.http.get<Post>(`/api/posts/${id}`).pipe(
      retry(2),                              // retry on failure
      timeout(5000),                         // abort after 5s
      catchError(err => {
        if (err.status === 404) return of(null);   // graceful fallback
        return throwError(() => new Error('Network error'));
      }),
    );
  }
}

// component-side
this.posts.getPost(1).subscribe({
  next: p => this.post = p,
  error: e => this.error = e.message,
  complete: () => this.loading = false,
});

Respuestas tipadas y withFetch

Los genéricos tipan el cuerpo de la respuesta pero no lo validan en tiempo de ejecución — para mayor seguridad, usa un validador en tiempo de ejecución como zod. observe: 'response' expone status, headers y body. withFetch() (v18) usa la Fetch API en lugar de XHR, lo que habilita streaming y un mejor renderizado en el servidor. withXsrfConfiguration añade manejo automático del token CSRF.

angular
// typed generic — response is typed, runtime NOT validated
this.http.get<User[]>('/api/users');

// full HttpResponse observation
this.http.get<User>('/api/users/1', { observe: 'response' })
  .subscribe(res => {
    console.log(res.status);   // 200
    console.log(res.headers.get('X-Total-Count'));
    console.log(res.body);     // User
  });

// opt into fetch() backend (v18+, recommended)
// provideHttpClient(withFetch())

// with XSRF protection enabled
// provideHttpClient(withXsrfConfiguration({ cookieName: 'XSRF-TOKEN' }))
10

Observables y RxJS

Observable básico

Los Observables son perezosos — el productor solo se ejecuta al suscribirse. Pueden emitir cero o más valores, y luego completar o dar error. El callback de subscribe recibe next, error y complete. Desuscríbete siempre de las suscripciones de larga vida (o usa el pipe async / takeUntilDestroyed). of() emite valores de forma sincrónica; from() aplana arrays o promesas.

angular
import { Observable } from 'rxjs';

const obs = new Observable<number>(subscriber => {
  subscriber.next(1);
  subscriber.next(2);
  setTimeout(() => {
    subscriber.next(3);
    subscriber.complete();
  }, 1000);
});

const sub = obs.subscribe({
  next: v => console.log(v),
  error: e => console.error(e),
  complete: () => console.log('done'),
});

// cleanup
sub.unsubscribe();

// use of(...) for synchronous values
of(1, 2, 3).subscribe(v => console.log(v));
// from(iterable) for arrays/async iterables
from([1, 2, 3]).subscribe(console.log);

Operadores comunes

Los operadores transforman los streams. map/filter funcionan como las funciones de array. debounceTime espera un periodo de silencio (ideal para inputs de búsqueda). distinctUntilChanged salta valores consecutivos duplicados. switchMap cancela el Observable interno anterior cuando llega un nuevo valor — perfecto para buscar mientras se escribe. Los operadores de pipe van de izquierda a derecha.

angular
import { of, from, interval } from 'rxjs';
import { map, filter, switchMap, debounceTime, distinctUntilChanged } from 'rxjs/operators';

of(1, 2, 3, 4).pipe(
  map(x => x * 10),                          // 10, 20, 30, 40
  filter(x => x > 15),                       // 20, 30, 40
).subscribe(console.log);

// search input with debounce
input$.pipe(
  debounceTime(300),
  distinctUntilChanged(),
  switchMap(term => http.get(`/api/search?q=${term}`)),
).subscribe(results => this.results = results);

Combinar streams

combineLatest emite cada vez que cualquier fuente emite (después de que todas hayan emitido al menos una vez) — ideal para estado de vista derivado. forkJoin espera a que todas las fuentes se completen y devuelve el último valor de cada una — úsalo para peticiones HTTP en paralelo. merge intercala las emisiones. zip empareja por índice. race elige el primer Observable que emite e ignora el resto.

angular
import { combineLatest, forkJoin, merge, race, zip } from 'rxjs';

// combineLatest: emits when ANY source emits, after all have emitted
combineLatest([user$, settings$]).subscribe(([u, s]) => ...);

// forkJoin: waits for all to complete, emits last values (like Promise.all)
forkJoin({ user: user$, posts: posts$ }).subscribe(r => ...);

// merge: emits values from all sources as they come
merge(clicks$, keys$).subscribe(e => ...);

// zip: pairs emissions by index
zip(range(1, 3), ['a', 'b', 'c']).subscribe(([n, letter]) => ...);

// race: takes the first to emit, ignores the rest
race(primary$, fallback$).subscribe(v => ...);

Subjects (multidifusión)

Los Subjects son a la vez Observables y Observers — llama a .next() para emitir valores. Subject: sin valor inicial, los suscriptores tardíos pierden las emisiones anteriores. BehaviorSubject: exige un valor inicial, los nuevos suscriptores reciben de inmediato el valor actual (útil para estado). ReplaySubject: almacena en búfer los últimos N valores para los nuevos suscriptores (útil para reproducir eventos).

angular
import { Subject, BehaviorSubject, ReplaySubject } from 'rxjs';

// Subject: emits to current subscribers only
const click$ = new Subject<MouseEvent>();
click$.subscribe(x => console.log('A:', x));
click$.next({} as MouseEvent);   // A: logs it

// BehaviorSubject: keeps last value, new subs get it immediately
const count$ = new BehaviorSubject(0);
count$.subscribe(v => console.log(v));   // logs 0 immediately
count$.next(1);                          // logs 1 to subscribers

// ReplaySubject: replays last N values to new subscribers
const recent$ = new ReplaySubject<string>(2);
recent$.next('a'); recent$.next('b'); recent$.next('c');
recent$.subscribe(v => console.log(v));  // logs 'b', then 'c'

takeUntil y limpieza

takeUntil(unsubscribe$) completa automáticamente una suscripción cuando el notificador emite — el patrón estándar para evitar fugas en los componentes. takeUntilDestroyed() (v16+) usa el DestroyRef de Angular para desuscribirse automáticamente sin el boilerplate de OnDestroy. Debe llamarse en un contexto de inyección (constructor o inicializador de campo) o aceptar un DestroyRef explícito.

angular
import { Subject, takeUntil, takeUntilDestroyed } from 'rxjs';

export class DemoComponent implements OnDestroy {
  private destroy$ = new Subject<void>();

  ngOnInit() {
    this.svc.stream$.pipe(
      takeUntil(this.destroy$),
    ).subscribe(data => this.data = data);
  }

  ngOnDestroy() { this.destroy$.next(); this.destroy$.complete(); }
}

// v16+: takeUntilDestroyed (uses DestroyRef, no boilerplate)
export class DemoComponent {
  data: any;
  constructor() {
    inject(SomeService).stream$.pipe(
      takeUntilDestroyed(),
    ).subscribe(d => this.data = d);
  }
}

switchMap vs mergeMap vs concatMap

Estos operadores de aplanado se diferencian en cómo manejan Observables internos superpuestos. switchMap cancela (búsqueda mientras se escribe). mergeMap paraleliza (cargar muchos). concatMap encola (conservar el orden). exhaustMap descarta (evitar dobles envíos). Elegir el incorrecto provoca condiciones de carrera — ajusta el operador a la semántica de cancelación del caso de uso.

angular
import { from, interval } from 'rxjs';
import { switchMap, mergeMap, concatMap, exhaustMap } from 'rxjs/operators';

// switchMap: cancels the previous inner stream on new value
input$.pipe(switchMap(term => search(term)));
// Best for: typeahead search (discard stale results)

// mergeMap: runs all inner streams in parallel
ids$.pipe(mergeMap(id => fetchDetail(id)));
// Best for: parallel requests, order doesn't matter

// concatMap: queues inner streams, runs one at a time
queue$.pipe(concatMap(task => runTask(task)));
// Best for: ordered sequential operations

// exhaustMap: ignores new values while inner stream is active
save$.pipe(exhaustMap(() => saveForm()));
// Best for: prevent double-submit (ignore clicks while saving)
11

Hooks del ciclo de vida

Visión general del orden de los hooks

Los hooks se disparan en un orden estricto. ngOnChanges se dispara con los cambios de @Input (y al inicio). ngOnInit se dispara una vez tras el primer ngOnChanges. ngDoCheck se ejecuta en cada ciclo de detección de cambios. Los hooks After* indican que el contenido/vista están listos para consultas al DOM. ngOnDestroy es el punto de limpieza — desuscríbete, libera recursos y cancela temporizadores.

angular
export class LifecycleComponent implements
    OnChanges, OnInit, DoCheck, AfterContentInit,
    AfterContentChecked, AfterViewInit, AfterViewChecked, OnDestroy {

  ngOnChanges()    { console.log('1. input changes'); }
  ngOnInit()       { console.log('2. component init (once)'); }
  ngDoCheck()      { console.log('3. custom change detection'); }
  ngAfterContentInit()      { console.log('4. projected content ready'); }
  ngAfterContentChecked()   { console.log('5. projected content checked'); }
  ngAfterViewInit()         { console.log('6. view (template) ready'); }
  ngAfterViewChecked()      { console.log('7. view checked'); }
  ngOnDestroy()    { console.log('8. cleanup before destroy'); }
}

ngOnInit y ngOnDestroy

ngOnInit se ejecuta una vez después de establecer los inputs — el lugar adecuado para la inicialización costosa (peticiones, suscripciones), ya que el constructor debe ser ligero. ngOnDestroy es el único hook que se llama al destruir el componente — nunca te saltes la limpieza aquí o tendrás fugas de suscripciones, temporizadores y listeners de eventos. El constructor es solo para la DI; usa ngOnInit para la lógica.

angular
export class ChartComponent implements OnInit, OnDestroy {
  private timer?: ReturnType<typeof setInterval>;

  ngOnInit() {
    // good for: data fetching, initialization, subscriptions
    this.timer = setInterval(() => this.refresh(), 5000);
    this.loadInitialData();
  }

  ngOnDestroy() {
    // cleanup: clear timers, unsubscribe, release resources
    if (this.timer) clearInterval(this.timer);
    // also: this.sub.unsubscribe();
  }

  private refresh() { /* ... */ }
  private loadInitialData() { /* ... */ }
}

ngOnChanges (SimpleChange)

ngOnChanges se dispara cuando cambia la referencia de un @Input, con un mapa SimpleChanges: cada entrada tiene previousValue, currentValue, firstChange e isFirstChange(). NO se dispara cuando mutas las propiedades de un objeto — solo cuando cambia la referencia. Para cambios profundos, usa ngOnChanges con un setter o ngDoCheck con IterableDiffers.

angular
export class PaginationComponent implements OnChanges {
  @Input() page = 1;
  @Input() total = 0;

  ngOnChanges(changes: SimpleChanges) {
    if (changes['page'] && !changes['page'].firstChange) {
      // react only when page actually changed (not on init)
      console.log('page:', changes['page'].previousValue, '->', changes['page'].currentValue);
      this.fetchPage(this.page);
    }
  }

  private fetchPage(p: number) { /* ... */ }
}

ngAfterViewInit y ViewChild

Las consultas ViewChild/ContentChild se resuelven DESPUÉS de sus respectivos hooks de inicio. ngAfterViewInit para los elementos de la propia plantilla del componente; ngAfterContentInit para el contenido proyectado vía <ng-content>. Acceder a estas referencias en ngOnInit devuelve undefined. La aserción de no nulo ! indica al compilador que se establece tras el inicio — pero solo es segura de usar en los hooks After*.

angular
export class CanvasComponent implements AfterViewInit {
  @ViewChild('canvas') canvasRef!: ElementRef<HTMLCanvasElement>;

  // ❌ canvasRef is undefined in ngOnInit
  ngOnInit() { /* this.canvasRef is undefined here */ }

  // ✅ available after view init
  ngAfterViewInit() {
    const canvas = this.canvasRef.nativeElement;
    const ctx = canvas.getContext('2d');
    ctx?.fillText('Hello', 10, 50);
  }
}

// template: <canvas #canvas></canvas>

ngDoCheck (detección personalizada)

ngDoCheck se ejecuta en cada ciclo de detección de cambios — mantenlo ligero. Usa IterableDiffers/KeyValueDiffers para detectar mutaciones de arrays/objetos que ngOnChanges no ve (porque las referencias no cambian). Es la vía de escape para rastrear mutaciones internas. Evita la lógica costosa aquí; se ejecuta con frecuencia y puede causar problemas de rendimiento.

angular
export class ListComponent implements DoCheck {
  @Input() items: Item[] = [];
  private differ: IterableDiffer<Item>;

  constructor(differs: IterableDiffers) {
    this.differ = differs.find(items).create<Item>((i) => i.id);
  }

  ngDoCheck() {
    const changes = this.differ.diff(this.items);
    if (changes) {
      changes.forEachAddedItem(r => console.log('Added:', r.item));
      changes.forEachRemovedItem(r => console.log('Removed:', r.item));
    }
  }
}

Hooks de contenido vs de vista

Los hooks de contenido (AfterContentInit/Checked) se disparan para el contenido proyectado vía <ng-content>. Los hooks de vista (AfterViewInit/Checked) se disparan para la propia plantilla del componente. Los hooks de contenido se disparan ANTES que los de vista porque el contenido se inicializa antes de que la vista se complete. @ContentChild consulta los elementos proyectados; @ViewChild consulta los elementos de la plantilla propia.

angular
export class CardComponent implements
    AfterContentInit, AfterViewInit, AfterContentChecked, AfterViewChecked {

  @ContentChild('header') headerTpl?: TemplateRef<unknown>;
  @ViewChild('body') bodyEl?: ElementRef<HTMLElement>;

  // projected content (<ng-content>) is ready
  ngAfterContentInit() {
    console.log('content ready:', this.headerTpl);
  }

  // own template view is ready
  ngAfterViewInit() {
    console.log('view ready:', this.bodyEl?.nativeElement);
  }

  // ContentChecked/ViewChecked run every CD cycle after init — beware perf
}
12

Proyección de contenido

ng-content básico

<ng-content> es un marcador donde se proyecta el contenido proporcionado por el padre. Piensa en él como el <slot> de Angular. Sin select, el contenido proyectado completo va aquí. El contenido proyectado se compila en el contexto del padre — los enlaces como {{ }} se resuelven contra el componente padre, no contra CardComponent.

angular
// card.component.ts
@Component({
  selector: 'app-card',
  template: `
    <div class="card">
      <ng-content></ng-content>
    </div>
  `,
  styles: ['.card { border: 1px solid #ccc; padding: 16px; }'],
})
export class CardComponent {}

<!-- usage: anything inside projects into <ng-content> -->
<app-card>
  <h3>Title</h3>
  <p>Body content here.</p>
</app-card>

Proyección multi-slot

El atributo select de ng-content apunta a contenido proyectado específico: por elemento ('header'), por atributo ('[header]'), por clase ('.active') o combinaciones ('div.foo[bar]'). El contenido sin coincidencia cae en el ng-content sin select. El contenido proyectado conserva los estilos y el contexto del padre — solo cambia su ubicación en el DOM.

angular
@Component({
  selector: 'app-layout',
  template: `
    <header><ng-content select="[header]"></ng-content></header>
    <main><ng-content></ng-content></main>
    <footer><ng-content select="footer"></ng-content></footer>
  `,
})
export class LayoutComponent {}

<!-- usage: select matches attributes, elements, classes -->
<app-layout>
  <nav header>Top nav</nav>
  <p>Main body</p>
  <footer>Bottom</footer>
</app-layout>

Proyección condicional (ng-template)

Para proyección condicional o repetida, ng-template con ngTemplateOutlet da control total. ContentChildren consulta las directivas proyectadas. ngTemplateOutlet renderiza un TemplateRef en la ubicación elegida — útil para pestañas, acordeones o slots condicionales. Este patrón desacopla la declaración del contenido de dónde y cuándo se renderiza.

angular
@Component({
  selector: 'app-tabs',
  template: `
    <div class="tabs">
      @for (t of tabs; track t) {
        <button (click)="active = t">{{ t.title }}</button>
      }
    </div>
    @for (t of tabs; track t) {
      @if (t === active) {
        <ng-container [ngTemplateOutlet]="t.template" />
      }
    }
  `,
})
export class TabsComponent {
  @ContentChildren(TabDirective) tabs!: QueryList<TabDirective>;
  active: any;
}

ContentChild y ContentChildren

@ContentChild / @ContentChildren consultan el contenido proyectado (frente a ViewChild para la plantilla propia). ContentChildren devuelve una QueryList que se actualiza cuando cambia el contenido. Se resuelve en ngAfterContentInit. La opción { descendants: true } (por defecto) recorre el contenido proyectado en toda su profundidad. Usa { read: ... } para consultar un tipo concreto (ElementRef, TemplateRef, etc.).

angular
@Directive({ selector: 'tab' })
export class TabDirective {
  @Input() title = '';
  @Input() active = false;
  @ContentChild(TemplateRef) template!: TemplateRef<unknown>;
}

@Component({
  selector: 'app-tabset',
  template: `
    @for (tab of tabs; track tab) {
      <button (click)="select(tab)">{{ tab.title }}</button>
    }
    <ng-container *ngTemplateOutlet="activeTab?.template" />
  `,
})
export class TabsetComponent implements AfterContentInit {
  @ContentChildren(TabDirective) tabs!: QueryList<TabDirective>;
  activeTab?: TabDirective;

  ngAfterContentInit() {
    this.activeTab = this.tabs.find(t => t.active) ?? this.tabs.first;
  }
}

ngTemplateOutlet con contexto

ngTemplateOutlet renderiza un TemplateRef con un contexto opcional. let-x se enlaza a context.$implicit (el valor por defecto); let-y='key' se enlaza a context.key. Así es como *ngFor y ngTemplateOutlet pasan las variables del bucle. Usa este patrón para plantillas reutilizables de listas/grids/elementos que los padres pueden personalizar mientras el componente controla la lógica de iteración.

angular
@Component({
  selector: 'app-list',
  template: `
    @for (item of items; track item.id) {
      <ng-container *ngTemplateOutlet="itemTpl; context: { $implicit: item, i: $index }" />
    }
    <ng-template #itemTpl let-item let-i="i">
      <li>{{ i }}: {{ item.name }}</li>
    </ng-template>
  `,
})
export class ListComponent {
  items = [{ id: 1, name: 'A' }, { id: 2, name: 'B' }];
}

Patrones de select en ng-content

select acepta selectores tipo CSS: clases (.x), atributos ([x]), elementos (header) o listas separadas por comas ('a, b'). El contenido que no coincide con ningún selector cae en el ng-content sin select. Si no hay respaldo, el contenido sin coincidencia se descarta. Los selectores comparan contra los atributos propios de los elementos proyectados, no contra su estructura interna.

angular
@Component({
  selector: 'app-modal',
  template: `
    <div class="modal">
      <ng-content select=".modal-header"></ng-content>
      <ng-content select="[body]"></ng-content>
      <ng-content select="app-modal-footer, footer"></ng-content>
      <!-- fallback for unmatched content -->
      <ng-content></ng-content>
    </div>
  `,
})

<!-- matches by class, attribute, element, or selector list -->
<app-modal>
  <div class="modal-header">Title</div>
  <section body>Body text</section>
  <app-modal-footer>OK</app-modal-footer>
  <p>This falls into the unselect'd slot.</p>
</app-modal>
13

Guards de ruta

CanActivate (funcional)

Los guards funcionales (v14.2+) devuelven true/false/UrlTree o un Observable/Promise de ellos. Devolver un UrlTree redirige a esa ruta. inject() funciona porque los guards se ejecutan en un contexto de inyección. CanActivate impide la navegación hacia una ruta. Registra los guards por ruta en el array canActivate. Se ejecutan en cada navegación hacia esa ruta.

angular
import { inject } from '@angular/core';
import { CanActivateFn, Router } from '@angular/router';

export const authGuard: CanActivateFn = (route, state) => {
  const auth = inject(AuthService);
  const router = inject(Router);

  if (auth.isLoggedIn) return true;

  // redirect to login, preserving the attempted URL
  return router.createUrlTree(['/login'], {
    queryParams: { returnUrl: state.url },
  });
};

// register in routes
{ path: 'dashboard', component: DashboardComponent, canActivate: [authGuard] }

CanActivateChild

CanActivateChild se ejecuta antes de cada ruta hija bajo el padre — más limpio que repetir canActivate en cada hija. Úsalo para la protección compartida de un área de funcionalidad. Devuelve los mismos tipos de valor que CanActivate. Para proteger también al padre, añade además canActivate en la ruta padre.

angular
export const adminGuard: CanActivateChildFn = (route, state) => {
  const auth = inject(AuthService);

  if (!auth.isAdmin) {
    return inject(Router).parseUrl('/forbidden');
  }
  return true;
};

// applies to all children of this route
{
  path: 'admin',
  canActivateChild: [adminGuard],
  children: [
    { path: 'users', component: AdminUsersComponent },
    { path: 'settings', component: AdminSettingsComponent },
  ],
}

CanDeactivate (proteger cambios sin guardar)

CanDeactivate se ejecuta antes de abandonar una ruta — perfecto para avisar sobre cambios sin guardar en formularios. El guard recibe la instancia del componente, así que puede invocar una función de esta. Devuelve false para cancelar la navegación, true para continuar. Para el caso asíncrono (confirmación con modal), devuelve un Observable o Promise. El componente debe implementar el contrato que el guard espera.

angular
import { CanDeactivateFn } from '@angular/router';
import { inject } from '@angular/core';

export interface CanComponentDeactivate {
  canDeactivate: () => boolean | Observable<boolean>;
}

export const unsavedGuard: CanDeactivateFn<CanComponentDeactivate> = (component) => {
  return component?.canDeactivate() ?? true;
};

// component
export class EditComponent implements CanComponentDeactivate {
  canDeactivate() {
    if (this.form.dirty) return confirm('Discard changes?');
    return true;
  }
}

// route: { path: 'edit/:id', canDeactivate: [unsavedGuard] }

CanMatch (carga condicional)

CanMatch (v14.1+) se ejecuta antes incluso de descargar el chunk de una ruta lazy — más eficiente que CanActivate para restringir funciones de pago. Si devuelve false, la ruta se omite por completo (las demás rutas que coincidan tienen su oportunidad). CanActivate descargaría primero el chunk y luego denegaría. Usa CanMatch para evitar descargar código al que el usuario no puede acceder.

angular
import { CanMatchFn } from '@angular/router';

export const paidFeatureGuard: CanMatchFn = (route, segments) => {
  const auth = inject(AuthService);
  // runs BEFORE the lazy chunk is even loaded
  if (auth.hasProPlan) return true;

  return inject(Router).createUrlTree(['/upgrade']);
};

// route configuration
{
  path: 'premium',
  canMatch: [paidFeatureGuard],
  loadComponent: () => import('./premium/premium.component'),
}

Resolve (precargar datos)

Resolve se ejecuta antes de que la ruta se active, retrasando la navegación hasta que lleguen los datos. Los datos resueltos quedan en route.snapshot.data. Útil para garantizar que los componentes tienen datos al renderizar (sin destello de estado vacío). Gestiona los errores dentro del resolver — devolver EMPTY cancela la navegación. Para cargas no bloqueantes, haz la petición en ngOnInit.

angular
import { ResolveFn } from '@angular/router';
import { inject } from '@angular/core';

export const userResolver: ResolveFn<User> = (route) => {
  const id = route.paramMap.get('id')!;
  return inject(UserService).getUser(+id).pipe(
    catchError(() => {
      inject(Router).navigate(['/users']);
      return EMPTY;
    }),
  );
};

// route
{ path: 'users/:id', resolve: { user: userResolver }, component: UserComponent }

// component reads pre-fetched data
export class UserComponent {
  user = this.route.snapshot.data['user'] as User;
  constructor(private route: ActivatedRoute) {}
}

Composición y orden de los guards

Varios guards se ejecutan en el orden del array; el primero que falla cancela la navegación. canMatch se ejecuta antes de cargar los chunks lazy; canActivate después. canDeactivate se ejecuta al salir. Los guards pueden ser sincrónicos (devuelven boolean) o asíncronos (Observable/Promise). Mantenlos rápidos — bloquean la UI. Las comprobaciones pesadas de servidor deberían aplicar debounce o cachear resultados.

angular
// multiple guards run in declaration order, all must pass
{
  path: 'admin',
  canActivate: [authGuard, roleGuard],
  canMatch: [paidFeatureGuard],
  canDeactivate: [unsavedGuard],
  loadChildren: () => import('./admin/admin.routes'),
}

// guard returning Observable (async check)
export const roleGuard: CanActivateFn = () => {
  return inject(AuthService).hasRole('admin').pipe(
    map(ok => ok || inject(Router).parseUrl('/forbidden')),
  );
};

// ordering: canMatch → resolve → canActivate → canActivateChild
14

Resolvers

Resolver básico (ResolveFn)

ResolveFn es la API funcional de resolvers. Se ejecuta antes de que la navegación se complete, y el valor devuelto se coloca en route.data bajo la clave que asignes. El componente puede leerlo sincrónicamente desde snapshot.data — sin necesidad de estado de carga. Suscríbete a route.data para actualizaciones reactivas al navegar entre rutas del mismo componente.

angular
import { ResolveFn } from '@angular/router';
import { inject } from '@angular/core';

export const postResolver: ResolveFn<Post> = (route, state) => {
  const id = Number(route.paramMap.get('id'));
  return inject(PostService).getPost(id);
};

// route
{
  path: 'posts/:id',
  resolve: { post: postResolver },
  component: PostDetailComponent,
}

// reading the resolved data
export class PostDetailComponent {
  post = this.route.snapshot.data['post'] as Post;
  constructor(private route: ActivatedRoute) {}

  // reactive: re-fetch when :id changes (same component reused)
  ngOnInit() {
    this.route.data.subscribe(d => this.post = d['post']);
  }
}

Varios resolvers

Varios resolvers se ejecutan en paralelo — cada uno debe completarse antes de que la ruta se active. Cada clave en resolve se convierte en una clave en route.data. Si uno falla, la navegación se cancela. Para datos independientes, es eficiente. Si uno depende de otro, anídalos o encadénalos en un solo resolver. Sopesa las ventajas de resolver frente a la petición en ngOnInit.

angular
{
  path: 'dashboard',
  component: DashboardComponent,
  resolve: {
    user: userResolver,
    stats: statsResolver,
    notifications: notifResolver,
  },
}

// component
export class DashboardComponent {
  constructor(private route: ActivatedRoute) {}
  ngOnInit() {
    const { user, stats, notifications } = this.route.snapshot.data;
    // all three resolved before component loads
  }
}

Gestión de errores en resolvers

Gestiona los errores del resolver explícitamente — los errores no capturados cancelan la navegación en silencio. EMPTY completa el stream sin emitir, cancelando la navegación. Devolver null permite que el componente maneje con elegancia los datos faltantes. Para los 404, redirige a una ruta de no encontrado. Registra o muestra siempre los errores; los fallos silenciosos son difíciles de depurar para el usuario.

angular
export const userResolver: ResolveFn<User | null> = (route) => {
  const id = route.paramMap.get('id')!;
  const router = inject(Router);
  const service = inject(UserService);

  return service.getUser(+id).pipe(
    catchError(err => {
      if (err.status === 404) {
        // redirect to a 'not found' page, cancel navigation
        router.navigate(['/404']);
        return EMPTY;
      }
      // re-throw other errors
      return throwError(() => err);
    }),
  );
};

Resolver vs petición en ngOnInit

Los resolvers bloquean la navegación hasta que llegan los datos — una UX limpia pero que se siente más lenta. La petición en ngOnInit no bloquea, pero requiere estados de carga en el componente. La guía moderna de Angular se inclina por lo no bloqueante: pide los datos en el componente con un skeleton de carga para una mejor percepción de rendimiento. Usa resolvers solo cuando el componente realmente no pueda renderizarse sin los datos.

angular
// Approach A: Resolver (blocks navigation until data arrives)
// ✅ Component renders with data — no flicker
// ❌ Slower navigation feel, blocks route transition
{
  path: 'user/:id',
  resolve: { user: userResolver },
  component: UserComponent,
}

// Approach B: Fetch in ngOnInit (non-blocking)
// ✅ Snappy navigation, show loading skeleton
// ❌ Component must handle null/loading state
export class UserComponent implements OnInit {
  user?: User;
  loading = true;
  ngOnInit() {
    this.route.params.subscribe(p => {
      this.loading = true;
      this.svc.getUser(+p['id']).subscribe(u => {
        this.user = u;
        this.loading = false;
      });
    });
  }
}

Resolver con query params y signals

Los resolvers pueden leer tanto paramMap como queryParamMap de la ruta. Cuando el mismo componente maneja parámetros distintos, suscríbete a route.data de forma reactiva en lugar de usar snapshot. Con signals, actualiza una signal desde la suscripción a los datos. Combina resolvers con signals para un flujo de datos limpio y reactivo. Evita los resolvers pesados — bloquean la navegación.

angular
// read query params inside a resolver
export const searchResolver: ResolveFn<SearchResult[]> = (route) => {
  const q = route.queryParamMap.get('q') ?? '';
  const page = Number(route.queryParamMap.get('page') ?? 1);
  return inject(SearchService).search(q, page);
};

// resolver feeding a signal-based component
export class SearchComponent {
  private route = inject(ActivatedRoute);
  results = signal<SearchResult[]>([]);

  constructor() {
    this.route.data.subscribe(d => this.results.set(d['results']));
  }
}
15

Animaciones

Configuración y animación básica

provideAnimations() registra el módulo de animaciones. trigger() define una animación con nombre; transition() declara el cambio entre estados. :enter y :leave son pseudoestados integrados para los elementos añadidos/eliminados con *ngIf o @if. Se aplican mediante @triggerName en la plantilla. Con el control de flujo de v17+, las animaciones siguen funcionando con @if/@for.

angular
// app.config.ts
import { provideAnimations } from '@angular/platform-browser/animations';
export const appConfig: ApplicationConfig = {
  providers: [provideAnimations()],
};

// component
@Component({
  selector: 'app-fade',
  animations: [
    trigger('fadeIn', [
      transition(':enter', [
        style({ opacity: 0 }),
        animate('300ms ease-in', style({ opacity: 1 })),
      ]),
      transition(':leave', [
        animate('300ms ease-out', style({ opacity: 0 })),
      ]),
    ]),
  ],
  template: `<div *ngIf="show" @fadeIn>Hello</div>`,
})

Estados y transiciones

state() define estilos con nombre en reposo. transition('a => b') anima del estado a al b; '<=>' es bidireccional. Enlaza el trigger a una expresión que devuelva el nombre del estado. Los estilos de estado se aplican de inmediato (sin animación); las transiciones animan entre ellos. Usa 'void' para elementos que aún no están en el DOM, y '*' como comodín.

angular
@Component({
  selector: 'app-toggle',
  animations: [
    trigger('openClose', [
      state('open', style({ height: '*', opacity: 1 })),
      state('closed', style({ height: '0', opacity: 0 })),
      transition('open => closed', animate('200ms ease-out')),
      transition('closed => open', animate('300ms ease-in')),
      // bidirectional shortcut: 'open <=> closed'
    ]),
  ],
  template: `
    <button (click)="isOpen = !isOpen">Toggle</button>
    <div [@openClose]="isOpen ? 'open' : 'closed'">Panel</div>
  `,
})
export class ToggleComponent { isOpen = false; }

Keyframes y animaciones en paralelo

keyframes() define pasos intermedios con offset (de 0 a 1) para un control fino — como los @keyframes de CSS. group() ejecuta animaciones en paralelo; sequence() las ejecuta una tras otra. Úsalos para componer efectos complejos de entrada/salida. Mantén las animaciones cortas (200-400ms) y respeta prefers-reduced-motion por accesibilidad.

angular
trigger('wiggle', [
  transition('* => *', [
    animate('600ms ease-in-out', keyframes([
      style({ transform: 'translateX(0)', offset: 0 }),
      style({ transform: 'translateX(-10px)', offset: 0.25 }),
      style({ transform: 'translateX(10px)', offset: 0.75 }),
      style({ transform: 'translateX(0)', offset: 1 }),
    ])),
  ]),
]),

// parallel/group animations
transition(':enter', [
  group([
    animate('300ms', style({ opacity: 1 })),
    animate('300ms', style({ transform: 'translateY(0)' })),
  ]),
]),

Lista animada (@for)

Aplica animaciones :enter/:leave a los elementos de @for — se disparan cuando se añaden o eliminan elementos. track garantiza que Angular identifique correctamente los elementos entre cambios, de modo que las animaciones se disparen al añadir/eliminar de verdad (no al reordenar). Las animaciones en listas pueden ir a tirones sin un tracking adecuado. Para animaciones de reordenación, usa query() y animateChild().

angular
@Component({
  selector: 'app-list',
  animations: [
    trigger('itemAnim', [
      transition(':enter', [
        style({ height: 0, opacity: 0 }),
        animate('200ms', style({ height: '*', opacity: 1 })),
      ]),
      transition(':leave', [
        animate('200ms', style({ height: 0, opacity: 0 })),
      ]),
    ]),
  ],
  template: `
    @for (item of items; track item.id) {
      <div @itemAnim>{{ item.name }}</div>
    }
  `,
})
export class AnimListComponent { items = [...]; }

Animaciones de rutas

Enlaza el trigger de animación al estado de activación del router-outlet. query(':enter'/:leave) apunta a los componentes enrutados que entran/salen. { optional: true } evita errores cuando uno de los lados no existe (la carga inicial no tiene :leave). position: absolute apila los componentes antiguo y nuevo durante la transición. Las animaciones de ruta dan transiciones tipo app entre vistas.

angular
@Component({
  selector: 'app-root',
  animations: [
    trigger('routeAnim', [
      transition('* => *', [
        query(':enter', [
          style({ opacity: 0, position: 'absolute', width: '100%' }),
          animate('300ms', style({ opacity: 1 })),
        ], { optional: true }),
        query(':leave', [
          animate('300ms', style({ opacity: 0 })),
        ], { optional: true }),
      ]),
    ]),
  ],
  template: `
    <div [@routeAnim]="o.isActivated ? o.activatedRoute : ''">
      <router-outlet #o="outlet"></router-outlet>
    </div>
  `,
})

Movimiento reducido y animaciones CSS

Respeta siempre prefers-reduced-motion por accesibilidad — a algunos usuarios les marea el movimiento. Las animaciones de Angular añaden ~50KB al bundle; para fundidos simples, las animaciones CSS puras pueden bastar. Usa las animaciones de Angular cuando necesites transiciones con estado (máquinas de estados), coordinación padre-hijo o animaciones de ruta. CSS es más ligero para efectos hover/fade.

angular
// respect prefers-reduced-motion
@Component({
  selector: 'app-safe-anim',
  animations: [
    trigger('fade', [
      transition(':enter', [
        style({ opacity: 0 }),
        animate('300ms', style({ opacity: 1 })),
      ]),
    ]),
  ],
  // or just use CSS — Angular animations add bundle weight
  template: `<div class="fade-in" @fade>Content</div>`,
  styles: [`
    @media (prefers-reduced-motion: reduce) {
      .fade-in { animation: none !important; transition: none !important; }
    }
  `],
})
16

Testing

Configuración de pruebas de componentes

TestBed configura el módulo de pruebas. Para componentes standalone, impórtalos directamente (no hacen falta declarations en TestBed.configureTestingModule). createComponent devuelve un ComponentFixture: usa .componentInstance para la clase, .nativeElement para el DOM y .detectChanges() para disparar la detección de cambios. beforeEach con async/await maneja compileComponents.

angular
import { ComponentFixture, TestBed } from '@angular/core/testing';
import { MyComponent } from './my.component';

describe('MyComponent', () => {
  let fixture: ComponentFixture<MyComponent>;
  let component: MyComponent;

  beforeEach(async () => {
    await TestBed.configureTestingModule({
      imports: [MyComponent],   // standalone components are imported
    }).compileComponents();

    fixture = TestBed.createComponent(MyComponent);
    component = fixture.componentInstance;
    fixture.detectChanges();   // runs initial change detection
  });

  it('should create', () => {
    expect(component).toBeTruthy();
  });
});

Pruebas con servicios mock

Proporciona implementaciones mock de los servicios para aislar el componente bajo prueba. jasmine.createSpy() permite controlar los valores devueltos y verificar las llamadas. Usa useValue para mocks de objetos y useClass para falsos basados en clases. Sustituye HttpClient por HttpTestingController en las pruebas HTTP. El mocking mantiene las pruebas rápidas y deterministas — sin llamadas de red reales.

angular
describe('UserComponent', () => {
  let mockUserService = {
    getUsers: jasmine.createSpy().and.returnValue(of([...])),
    addUser: jasmine.createSpy().and.returnValue(of({})),
  };

  beforeEach(async () => {
    await TestBed.configureTestingModule({
      imports: [UserComponent],
      providers: [
        { provide: UserService, useValue: mockUserService },
      ],
    }).compileComponents();
  });

  it('loads users on init', () => {
    const fixture = TestBed.createComponent(UserComponent);
    fixture.detectChanges();
    expect(mockUserService.getUsers).toHaveBeenCalled();
    expect(fixture.componentInstance.users.length).toBe(2);
  });
});

Pruebas HTTP

HttpTestingController intercepta las llamadas de HttpClient en las pruebas — sin red real. expectOne verifica que se hizo una petición y la devuelve; flush() simula la respuesta del servidor. verify() garantiza que no quedan peticiones sin emparejar. Prueba los caminos de éxito y de error: flush con un código de estado (por ejemplo, { status: 500, statusText: 'Server Error' }) para simular errores.

angular
import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
import { provideHttpClient } from '@angular/common/http';

describe('PostService', () => {
  let service: PostService;
  let httpMock: HttpTestingController;

  beforeEach(() => {
    TestBed.configureTestingModule({
      providers: [
        PostService,
        provideHttpClient(),
        provideHttpClientTesting(),
      ],
    });
    service = TestBed.inject(PostService);
    httpMock = TestBed.inject(HttpTestingController);
  });

  it('fetches posts', () => {
    service.getPosts().subscribe(posts => expect(posts.length).toBe(2));

    const req = httpMock.expectOne('/api/posts');
    expect(req.request.method).toBe('GET');
    req.flush([{ id: 1 }, { id: 2 }]);   // simulate response
    httpMock.verify();                    // no outstanding requests
  });
});

Pruebas de plantilla e interacciones

fixture.nativeElement da acceso directo al DOM para aserciones. detectChanges() sincroniza los enlaces de la plantilla tras establecer propiedades. spyOn permite verificar llamadas a funciones. Para consultas internas del componente, debugElement.query(By.css()) es más seguro en tipos. Dispara eventos mediante las funciones nativas del DOM (click()) o DebugElement.triggerEventHandler para eventos personalizados.

angular
it('renders the title', () => {
  const fixture = TestBed.createComponent(MyComponent);
  fixture.componentInstance.title = 'Hello';
  fixture.detectChanges();
  const el: HTMLElement = fixture.nativeElement;
  expect(el.querySelector('h1')?.textContent).toContain('Hello');
});

it('calls save on button click', () => {
  const fixture = TestBed.createComponent(MyComponent);
  const spy = spyOn(fixture.componentInstance, 'save');
  const button = fixture.nativeElement.querySelector('button');
  button.click();
  expect(spy).toHaveBeenCalled();
});

// By.css for debug element queries (faster than nativeElement)
const debugEl = fixture.debugElement.query(By.css('.submit'));

Pruebas con signals

Las signals son funciones — llámalas (con paréntesis) para leer sus valores en las pruebas. set() actualiza directamente las signals escribibles, evitando la manipulación indirecta. detectChanges() sincroniza las plantillas basadas en signals. Para computed/effect, detectChanges o TestBed.flushEffects() garantizan que los efectos dependientes se ejecuten. Las signals hacen las pruebas más sincrónicas y predecibles.

angular
describe('CounterComponent', () => {
  it('increments count', () => {
    const fixture = TestBed.createComponent(CounterComponent);
    const comp = fixture.componentInstance;

    expect(comp.count()).toBe(0);
    comp.increment();
    expect(comp.count()).toBe(1);

    // force signal effects to run in tests
    fixture.detectChanges();
  });

  it('renders count in template', () => {
    const fixture = TestBed.createComponent(CounterComponent);
    fixture.componentInstance.count.set(5);
    fixture.detectChanges();   // syncs signal to template
    expect(fixture.nativeElement.textContent).toContain('5');
  });
});

E2E con Cypress / Playwright

Las pruebas E2E ejercitan toda la app en un navegador real. Usa atributos data-cy como selectores — son estables y no se acoplan a clases CSS. Cypress se ejecuta en el navegador; Playwright, en varios navegadores. Usa ng e2e o configura Cypress/Playwright manualmente. Las pruebas E2E detectan problemas de integración que las unitarias pasan por alto, pero son más lentas — mantén la suite enfocada.

angular
// cypress test (cypress/e2e/login.cy.ts)
describe('Login flow', () => {
  beforeEach(() => cy.visit('/login'));

  it('logs in with valid credentials', () => {
    cy.get('[data-cy=email]').type('[email protected]');
    cy.get('[data-cy=password]').type('secret123');
    cy.get('[data-cy=submit]').click();

    cy.url().should('include', '/dashboard');
    cy.contains('Welcome, User');
  });
});

// run with: npx cypress open  (interactive)
//           npx cypress run   (headless CI)
17

PWA

Añadir soporte PWA

ng add @angular/pwa genera cada pieza: registro del service worker, web manifest e iconos. El service worker solo funciona en compilaciones de producción (ng build --configuration production) — está desactivado en desarrollo para evitar sorpresas de caché. registrationStrategy controla cuándo se registra el SW; registerWhenStable espera a que la app se estabilice.

angular
# add @angular/service-worker
ng add @angular/pwa --project my-app

# this generates:
# - ngsw-config.json (service worker config)
# - manifest.webmanifest
# - icons in src/assets/icons/
# - registers service worker in app.config.ts

# app.config.ts (auto-updated)
export const appConfig: ApplicationConfig = {
  providers: [
    provideRouter(routes),
    provideServiceWorker('ngsw-worker.js', {
      enabled: environment.production,
      registrationStrategy: 'registerWhenStable:30000',
    }),
  ],
};

Configuración del service worker (ngsw-config.json)

assetGroups cachea el app shell (prefetch) y los recursos estáticos (lazy). dataGroups cachea respuestas de API con estrategias freshness/performance y TTLs. prefetch descarga de forma anticipada; lazy descarga bajo demanda. freshness prueba primero la red y recurre a la caché (bueno para datos frescos); performance usa primero la caché (bueno para datos casi estáticos).

angular
{
  "$schema": "./node_modules/@angular/service-worker/config/schema.json",
  "index": "/index.html",
  "assetGroups": [
    {
      "name": "app",
      "installMode": "prefetch",
      "updateMode": "prefetch",
      "resources": {
        "files": ["/favicon.ico", "/index.html", "/manifest.webmanifest", "/*.css", "/*.js"]
      }
    },
    {
      "name": "assets",
      "installMode": "lazy",
      "updateMode": "prefetch",
      "resources": { "files": ["/assets/**", "/*.(svg|png|jpg|jpeg|webp|woff2)"] }
    }
  ],
  "dataGroups": [
    {
      "name": "api",
      "urls": ["https://api.example.com/**"],
      "cacheConfig": {
        "maxSize": 100, "maxAge": "1d", "timeout": "10s", "strategy": "freshness"
      }
    }
  ]
}

Gestión de actualizaciones

SwUpdate avisa cuando hay una nueva versión disponible. VERSION_READY significa que un nuevo bundle se descargó y está listo para activarse. activateUpdate() cambia a la nueva versión; recarga para aplicarla. Para actualizaciones críticas, activa de inmediato. Para las que no, pregunta al usuario. Suscríbete a versionUpdates para manejar VERSION_DETECTED, VERSION_READY y NO_NEW_VERSION_DETECTED.

angular
import { SwUpdate } from '@angular/service-worker';
import { inject } from '@angular/core';

export class UpdatePromptComponent {
  private updates = inject(SwUpdate);
  updateAvailable = false;

  constructor() {
    this.updates.versionUpdates.subscribe(evt => {
      if (evt.type === 'VERSION_READY') {
        this.updateAvailable = true;
      }
    });
  }

  applyUpdate() {
    this.updates.activateUpdate().then(() => document.location.reload());
  }
}

Soporte sin conexión y caché

SwPush habilita las notificaciones push web vía el service worker. requestSubscription pide permiso al usuario y devuelve un objeto de suscripción para enviar a tu servidor. El SW recibe los eventos push incluso con la pestaña cerrada. Las claves VAPID autentican tu servidor. Combínalo con la API Notification para mostrar mensajes; gestiona los clics para navegar dentro de la app.

angular
import { SwPush } from '@angular/service-worker';

export class NotificationComponent {
  private swPush = inject(SwPush);

  subscribeToPush() {
    this.swPush.requestSubscription({
      serverPublicKey: this.VAPID_PUBLIC,
    }).then(sub => this.sendToServer(sub))
      .catch(err => console.error('Push denied', err));
  }

  // check if SW is enabled
  ngOnInit() {
    if (!this.swPush.isEnabled) {
      console.warn('Push notifications not supported');
    }
  }
}

Manifest de la app

El web manifest hace que la app sea instalable (Añadir a la pantalla de inicio). name/short_name se muestran en la pantalla de inicio; theme_color tiñe la UI del navegador; display: standalone elimina la interfaz del navegador para una sensación de app. Proporciona varios tamaños de icono (192, 512) además de un icono maskable para Android. Verifica la instalabilidad con la auditoría PWA de Lighthouse.

angular
<!-- index.html (added by ng add @angular/pwa) -->
<link rel="manifest" href="manifest.webmanifest">
<meta name="theme-color" content="#1976d2">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<link rel="apple-touch-icon" href="assets/icons/icon-152x152.png">

// manifest.webmanifest
{
  "name": "My App",
  "short_name": "MyApp",
  "theme_color": "#1976d2",
  "background_color": "#fafafa",
  "display": "standalone",
  "scope": "/",
  "start_url": "/",
  "icons": [
    { "src": "assets/icons/icon-192x192.png", "sizes": "192x192", "type": "image/png" },
    { "src": "assets/icons/icon-512x512.png", "sizes": "512x512", "type": "image/png" }
  ]
}

Instalabilidad y Lighthouse

beforeinstallprompt se dispara en Chrome cuando la app es instalable y te permite aplazar el prompt nativo. Guarda el evento y dispara prompt() desde un gesto del usuario (clic en un botón). iOS Safari no dispara este evento — los usuarios instalan desde el menú Compartir. Ejecuta la auditoría PWA de Lighthouse para verificar la instalabilidad. Las PWA funcionan sin conexión solo cuando el service worker cachea el app shell.

angular
// detect install prompt (Chrome)
let deferredPrompt: any;
window.addEventListener('beforeinstallprompt', (e) => {
  e.preventDefault();
  deferredPrompt = e;
  this.canInstall = true;   // show "Install App" button
});

// user-triggered install (must be from user gesture)
async installApp() {
  if (!deferredPrompt) return;
  deferredPrompt.prompt();
  const { outcome } = await deferredPrompt.userChoice;
  console.log('Install:', outcome);
  deferredPrompt = null;
}

// Lighthouse PWA checklist:
// ✅ served over HTTPS
// ✅ registers a service worker
// ✅ has a web manifest with icons
// ✅ start_url loads offline
18

Componentes standalone

Bootstrap de apps standalone

bootstrapApplication arranca una app standalone — sin NgModule. El AppComponent raíz debe ser standalone. app.config.ts centraliza los providers (router, http, animaciones, configuración de zone). Es el valor por defecto desde v17. Cada función provideX() conecta un subsistema. Mucho más limpio que AppModule + los providers de AppModule.

angular
// main.ts
import { bootstrapApplication } from '@angular/platform-browser';
import { appConfig } from './app/app.config';
import { AppComponent } from './app/app.component';

bootstrapApplication(AppComponent, appConfig)
  .catch(err => console.error(err));

// app.config.ts
import { ApplicationConfig, provideZoneChangeDetection } from '@angular/core';
import { provideRouter } from '@angular/router';
import { provideHttpClient } from '@angular/common/http';
import { routes } from './app.routes';

export const appConfig: ApplicationConfig = {
  providers: [
    provideZoneChangeDetection({ eventCoalescing: true }),
    provideRouter(routes),
    provideHttpClient(),
  ],
};

Imports de componentes standalone

standalone: true marca el componente como autosuficiente. El array imports enumera cada pieza que la plantilla necesita: módulos, componentes, directivas y pipes. Con el control de flujo de v17+ (@if/@for), no necesitas CommonModule para eso. Importa solo lo que se usa para mejorar el tree-shaking. Los componentes standalone pueden usarse en NgModules vía exports.

angular
@Component({
  selector: 'app-user-list',
  standalone: true,
  imports: [
    CommonModule,          // *ngIf, *ngFor, pipes (or use built-in @if/@for)
    FormsModule,           // ngModel
    UserCardComponent,     // another standalone component
    HighlightDirective,    // standalone directive
    TruncatePipe,          // standalone pipe
  ],
  template: `
    <input [(ngModel)]="filter" />
    @for (u of users; track u.id) {
      <app-user-card [user]="u" appHighlight>{{ u.name | truncate:20 }}</app-user-card>
    }
  `,
})
export class UserListComponent { ... }

Rutas standalone y carga diferida

loadComponent carga con lazy loading un único componente standalone — el chunk más pequeño posible. loadChildren carga con lazy loading un archivo de rutas (exportación por defecto de Routes). Ambos usan import() dinámico con una ruta estática para que el bundler divida. Esto reemplaza por completo a los feature modules. Cada ruta lazy obtiene su propio archivo JS, cargado en la primera navegación.

angular
export const routes: Routes = [
  { path: '', loadComponent: () => import('./home/home.component')
      .then(m => m.HomeComponent) },
  {
    path: 'admin',
    loadComponent: () => import('./admin/admin.component')
      .then(m => m.AdminComponent),
    canMatch: [authGuard],
  },
  {
    path: 'reports',
    loadChildren: () => import('./reports/reports.routes')
      .then(m => m.REPORTS_ROUTES),
  },
];

Directivas y pipes standalone

Las directivas y los pipes también pueden ser standalone (v15+). Añade standalone: true e impórtalos en cualquier componente que los necesite. Esto elimina la necesidad de declararlos en un módulo compartido. Por compatibilidad con versiones anteriores, las directivas/pipes standalone pueden seguir añadiéndose a los exports de un NgModule para usarlos en componentes basados en NgModule.

angular
@Directive({
  selector: '[appHighlight]',
  standalone: true,
})
export class HighlightDirective { ... }

@Pipe({
  name: 'truncate',
  standalone: true,
})
export class TruncatePipe implements PipeTransform { ... }

// use directly in a standalone component's imports
@Component({
  imports: [HighlightDirective, TruncatePipe],
  template: `<p appHighlight>{{ text | truncate:10 }}</p>`,
})

Migrar desde NgModule

El schematic automatiza la migración: convierte todas las declarations en standalone, mueve los imports del NgModule al array imports de cada componente y elimina los módulos obsoletos. Ejecútalo de forma incremental — puede ser parcial. Tras la migración, puedes borrar AppRoutingModule, AppModule y usar bootstrapApplication. El resultado es una app más ligera y con mejor tree-shaking.

angular
# automatic migration (v15.2+)
ng generate @angular/core:standalone

# options:
# 1. Convert all components/directives/pipes to standalone
# 2. Remove unnecessary NgModule classes
# 3. Bootstrap the app using bootstrapApplication

// before: declared in a module
@NgModule({
  declarations: [OldComponent],
  imports: [CommonModule],
  exports: [OldComponent],
})
export class OldModule {}

// after: standalone component
@Component({
  standalone: true,
  imports: [CommonModule],
  // ...
})
export class OldComponent {}

Inyección en providers standalone

Las apps standalone configuran los providers en app.config.ts en lugar del AppModule. APP_INITIALIZER ejecuta la configuración antes del bootstrap. Los providers a nivel de componente se limitan al subárbol de ese componente. Para los servicios, providedIn: 'root' sigue siendo lo preferido — es tree-shakeable. Usa arrays de providers para valores que no son servicios (tokens, configs, mocks).

angular
// app.config.ts — global providers
export const appConfig: ApplicationConfig = {
  providers: [
    { provide: API_URL, useValue: 'https://api.example.com' },
    { provide: ErrorHandler, useClass: GlobalErrorHandler },
    { provide: APP_INITIALIZER, multi: true, useFactory: () => initApp },
  ],
};

// component-level providers (scoped to this component and children)
@Component({
  providers: [
    { provide: UserService, useClass: MockUserService },
  ],
})
export class AdminComponent {}

// tree-shakable service
@Injectable({ providedIn: 'root' })  // preferred over providers array
export class AuthService {}
19

Signals

Crear signals

signal() crea un valor reactivo. Se lee llamándola: count(). Se actualiza con set() (reemplazar) o update() (calcular a partir del anterior). Las signals son sincrónicas y evitan la sobrecarga de los Observables para estado simple. En las plantillas puedes llamarlas con () — desde v17.2+ también se desempaquetan automáticamente en algunos contextos. Las signals se integran con la detección de cambios OnPush.

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

export class CounterComponent {
  // writable signal with initial value
  count = signal(0);
  user = signal<User | null>(null);

  // reading: call the signal as a function
  current = this.count();    // 0

  // writing
  increment() { this.count.update(v => v + 1); }
  setFive() { this.count.set(5); }

  // in templates, signals are called automatically in v17.2+
  // {{ count }} or {{ count() }} both work in templates
}

Signals calculadas (computed)

computed() crea una signal derivada y de solo lectura que rastrea automáticamente sus dependencias y cachea su valor. Solo recalcula cuando cambia una dependencia Y se vuelve a leer — evaluación perezosa. Las signals computadas pueden depender de otras signals computadas, formando un grafo. A diferencia de las funciones, cachean los resultados. Esto reemplaza muchos usos de combineLatest de RxJS.

angular
export class CartComponent {
  items = signal<Item[]>([]);
  taxRate = signal(0.08);

  // derived state — recomputes only when items or taxRate change
  subtotal = computed(() =>
    this.items().reduce((sum, i) => sum + i.price * i.qty, 0)
  );
  tax = computed(() => Math.round(this.subtotal() * this.taxRate() * 100) / 100);
  total = computed(() => this.subtotal() + this.tax());

  // computed signals are readonly and cached
  // they recompute lazily only when read AND a dependency changed
}

Effects (efectos secundarios)

effect() ejecuta un efecto secundario cuando cambian sus dependencias de signal. Úsalo para logging, sincronizar con localStorage, pedir datos o manipular el DOM. Los effects se ejecutan tras la detección de cambios. Evita escribir en signals que se leen en el mismo effect — eso crea bucles infinitos. onCleanup registra la lógica de limpieza para la siguiente ejecución. Los effects deben crearse en un contexto de inyección.

angular
export class SearchComponent {
  query = signal('');
  results = signal<Result[]>([]);

  constructor() {
    // effect runs when its signal dependencies change
    effect(() => {
      const q = this.query();
      // ⚠️ avoid setting signals read in this effect (causes loops)
      this.search(q).then(r => this.results.set(r));
    });
  }

  // effect with cleanup
  private log = effect((onCleanup) => {
    const id = setInterval(() => console.log(this.count()), 1000);
    onCleanup(() => clearInterval(id));
  });
}

Signals en plantillas (OnPush)

Las signals se integran a la perfección con OnPush — Angular sabe exactamente qué vistas dependen de una signal y marca solo esas para comprobación cuando cambia. No hace falta markForCheck() manual. En las plantillas, llama a las signals con () para leerlas. OnPush + signals es la configuración de detección de cambios más eficiente, y a menudo permite prescindir por completo de zone.js (modo zoneless).

angular
@Component({
  selector: 'app-todo',
  // signals work great with OnPush — automatic efficiency
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: `
    <input (input)="text.set($any($event.target).value)" />
    <p>You typed: {{ text() }}</p>
    <p>Length: {{ length() }}</p>
    <button (click)="clear()">Clear</button>
  `,
})
export class TodoComponent {
  text = signal('');
  length = computed(() => this.text().length);
  clear() { this.text.set(''); }
}

Inputs y consultas de signals

input()/input.required() crean inputs de signal de solo lectura. output() crea outputs tipados. model() crea inputs de signal enlazables en ambos sentidos (con un output xChange generado automáticamente). viewChild()/contentChild() devuelven signals que se resuelven tras el inicio de la vista — llámalas con () para leerlas. Estas APIs modernas reemplazan a los decoradores @Input/@Output/@ViewChild con signals reactivas.

angular
import { input, output, viewChild, contentChild, model } from '@angular/core';

export class EditComponent {
  // signal input (readonly, v17.1+)
  id = input<number>(0);
  requiredName = input.required<string>();

  // signal output (v17.3+)
  saved = output<User>();

  // two-way signal (v17.2+)
  value = model<number>(0);   // creates input + output named valueChange

  // signal queries
  inputEl = viewChild<ElementRef>('input');      // in own template
  header = contentChild<TemplateRef>('header');  // projected content

  focus() { this.inputEl()?.nativeElement.focus(); }
}

Interoperabilidad de signals y RxJS

toSignal convierte un Observable en una signal (se suscribe una vez y se desuscribe al destruirse). toObservable hace lo inverso. Usa la interoperabilidad para mezclar signals (estado sincrónico) con RxJS (flujos asíncronos complejos como búsquedas con debounce). takeUntilDestroyed se desuscribe automáticamente vía DestroyRef. initialValue evita lecturas de undefined antes de la primera emisión. Requiere un contexto de inyección.

angular
import { toSignal, toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';

export class SearchComponent {
  private http = inject(HttpClient);

  // Observable → Signal (one-way)
  results = toSignal(this.http.get<Result[]>('/api/results'), {
    initialValue: [] as Result[],
  });

  // Signal → Observable (for RxJS operators)
  private query$ = toObservable(this.query);

  // combine the best of both worlds
  filtered = toSignal(
    this.query$.pipe(
      debounceTime(300),
      switchMap(q => this.http.get(`/api/search?q=${q}`)),
      takeUntilDestroyed(),
    ),
    { initialValue: [] as Result[] },
  );
}
20

NgModules y arquitectura

Estructura de un NgModule

Los NgModules organizan la app en bloques cohesivos. declarations lista lo que el módulo posee. imports trae las exportaciones de otros módulos. exports expone las declarations a quien importe. Solo el módulo raíz define bootstrap. El Angular moderno favorece los componentes standalone (sin NgModule), pero las apps con NgModule siguen existiendo. Entiende ambos — las bases de código antiguas y algunas librerías usan módulos.

angular
@NgModule({
  declarations: [                  // components, directives, pipes owned by this module
    AppComponent,
    UserListComponent,
    HighlightDirective,
    TruncatePipe,
  ],
  imports: [                       // other modules whose exports this module needs
    BrowserModule,
    FormsModule,
    HttpClientModule,
    AppRoutingModule,
  ],
  exports: [                       // what's visible to modules that import this module
    UserListComponent,
    TruncatePipe,
  ],
  providers: [],                   // services (use providedIn: 'root' instead)
  bootstrap: [AppComponent],       // only in the root module
})
export class AppModule {}

Feature y shared modules

SharedModule agrupa componentes/directivas/pipes de UI comunes para reutilizarlos entre funcionalidades — reexporta CommonModule y FormsModule para que quien importe no tenga que hacerlo. Los feature modules encapsulan un área de funcionalidad; forChild() permite que el mismo módulo se configure distinto en cada importación (por ejemplo, routing). En apps standalone, prefiere componentes standalone individuales antes que módulos compartidos.

angular
// shared.module.ts — reusable UI bits
@NgModule({
  imports: [CommonModule, FormsModule],
  declarations: [ButtonComponent, CardComponent, HighlightDirective],
  exports: [ButtonComponent, CardComponent, HighlightDirective, FormsModule],
})
export class SharedModule {}

// feature module (lazy-loaded)
@NgModule({
  declarations: [AdminComponent, AdminUsersComponent],
  imports: [CommonModule, RouterModule, SharedModule],
  exports: [AdminComponent],
})
export class AdminModule {
  static forChild(): ModuleWithProviders<AdminModule> {
    return { ngModule: AdminModule, providers: [AdminService] };
  }
}

Core module y servicios singleton

CoreModule guarda los singletons de toda la app (servicios, interceptores, manejadores de error) y se importa una sola vez en AppModule. El guard del constructor evita la reimportación accidental (que crearía instancias duplicadas del servicio). En apps standalone, estos providers se mueven a app.config.ts. El patrón CoreModule es herencia del pasado, pero lo encontrarás en bases de código anteriores a v14.

angular
// core.module.ts — app-wide singletons, imported once in AppModule
@NgModule({
  providers: [
    AuthService,
    { provide: HTTP_INTERCEPTORS, useClass: AuthInterceptor, multi: true },
    { provide: ErrorHandler, useClass: GlobalErrorHandler },
  ],
})
export class CoreModule {
  // guard against importing twice
  constructor(@Optional() @SkipSelf() parent?: CoreModule) {
    if (parent) throw new Error('CoreModule already loaded');
  }
}

Patrón forRoot vs forChild

forRoot configura la instancia raíz (se llama una vez en AppModule); forChild registra rutas hijas (se llama en los feature modules). Este patrón lo usa RouterModule y los módulos de librerías que necesitan configuración. El Angular moderno lo reemplaza con funciones provideX() en app.config.ts. El patrón sigue apareciendo en librerías de terceros — entiéndelo para las integraciones.

angular
// classic RouterModule pattern
@NgModule({ imports: [CommonModule], exports: [RouterModule] })
export class RouterModule {
  static forRoot(routes: Routes): ModuleWithProviders<RouterModule> {
    return {
      ngModule: RouterModule,
      providers: [provideRouter(routes)],
    };
  }
  static forChild(routes: Routes): ModuleWithProviders<RouterModule> {
    return { ngModule: RouterModule, providers: [provideRoutes(routes)] };
  }
}

// AppModule imports: RouterModule.forRoot(ROUTES)
// FeatureModule imports: RouterModule.forChild(FEATURE_ROUTES)

// modern equivalent: provideRouter(routes) in app.config.ts

Entry components y componentes dinámicos

entryComponents (obsoleto) listaba componentes creados dinámicamente (diálogos, modales). El Angular moderno usa ViewContainerRef.createComponent() o NgComponentOutlet — sin registro previo. Esto funciona a la perfección con componentes standalone. createComponent devuelve un ComponentRef con .instance y .destroy(). Llama a destroy() para limpiar y evitar fugas.

angular
// older API: entryComponents for dynamically created components
@NgModule({
  entryComponents: [DialogComponent, ModalComponent],
})
export class AppModule {}

// modern: ViewContainerRef.createComponent (no entryComponents needed)
export class DialogService {
  constructor(private vcr: ViewContainerRef) {}

  open() {
    const ref = this.vcr.createComponent(DialogComponent);
    ref.instance.title = 'Hello';
    ref.instance.close.subscribe(() => ref.destroy());
    return ref;
  }
}

// even simpler: NgComponentOutlet in template
<ng-container *ngComponentOutlet="dialogComponent; inputs: { title: 'Hi' }" />

Módulos con carga diferida

Los módulos con carga diferida crean un chunk JS aparte que se carga al navegar. El import() dinámico debe ser una cadena estática para que el bundler pueda dividir. Los módulos lazy tienen su propio inyector raíz — los servicios con providedIn dentro de un módulo lazy no son singletons en toda la app. Las apps standalone modernas usan loadComponent/loadChildren con archivos de rutas, que es más simple y granular.

angular
// classic lazy module (pre-standalone)
const routes: Routes = [
  {
    path: 'admin',
    loadChildren: () => import('./admin/admin.module').then(m => m.AdminModule),
  },
];

// admin-routing.module.ts
const routes: Routes = [
  { path: '', component: AdminComponent },
  { path: 'users', component: AdminUsersComponent },
];

@NgModule({
  imports: [RouterModule.forChild(routes)],
  exports: [RouterModule],
})
export class AdminRoutingModule {}

// admin.module.ts
@NgModule({
  declarations: [AdminComponent, AdminUsersComponent],
  imports: [CommonModule, AdminRoutingModule],
})
export class AdminModule {}

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.