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.
# 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 --routingVisió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.
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.jsonServir 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.
# 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 e2eGeneració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.
# 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/roleConfiguració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.
{
"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.
// 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;
}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.
// 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.
@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.
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+.
@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.
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.
@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)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.
<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.
<!-- 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.
<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.
<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+.
<!-- [()] = "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.
<!-- 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) { ... }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.
@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.
<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.
<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+.
@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.
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.
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> -->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.
<!-- 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.
<!-- 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.
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.
@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.
// 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.
// 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 -->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.
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.
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.
@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.
// 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.
// 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.
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 componentEnrutado
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.
// 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).
<!-- 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.
// 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.
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.
// 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.
// 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
});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'.
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.
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.
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.
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.
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.
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(); }
}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.
// 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.
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 completeQuery 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.
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.
// 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.
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.
// 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' }))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.
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.
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.
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).
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.
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.
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)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.
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.
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.
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*.
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.
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.
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
}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.
// 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.
@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.
@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.).
@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.
@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.
@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>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.
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.
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.
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.
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.
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.
// 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 → canActivateChildResolvers
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.
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.
{
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.
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.
// 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.
// 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']));
}
}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.
// 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.
@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.
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().
@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.
@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.
// 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; }
}
`],
})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.
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.
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.
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.
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.
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.
// 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)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.
# 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).
{
"$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.
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.
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.
<!-- 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.
// 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 offlineComponentes 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.
// 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.
@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.
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.
@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.
# 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).
// 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 {}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.
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.
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.
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).
@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.
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.
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[] },
);
}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.
@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.
// 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.
// 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.
// 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.tsEntry 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.
// 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.
// 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 {}Fragmentos de Angular relacionados
Copy-paste ready code for common tasks.
Component Basics
Define an Angular component with selector, template, and styles.
Template Syntax & Binding
Interpolation, property, event, and two-way binding in Angular templates.
Built-in Directives
Use *ngIf, *ngFor, ngClass, and ngStyle to shape the DOM.
Pipes & Custom Pipe
Transform template values with built-in and custom pipes.
Services & Dependency Injection
Create an injectable service and consume it in a component.
Routing Configuration
Define routes with params, lazy loading, and redirects.
Reactive Forms
Build a typed reactive form with FormBuilder and validators.
HttpClient & RxJS
Perform typed HTTP requests with HttpClient and Observables.
Was this helpful?