Introducción

Angular 22 llegó en marzo de 2026 consolidando una estrategia clara de reactividad y de modernización de la arquitectura del framework. Si trabajas con proyectos corporativos de gran escala o estás decidiendo entre Angular y React, este es el momento adecuado para entender por qué Angular cambió radicalmente su enfoque y qué significa eso para tu stack.

Pasé los últimos meses integrando Angular 22 en proyectos complejos y me di cuenta de que gran parte de la confusión que tienen los desarrolladores proviene de comparaciones superficiales o de información desactualizada sobre el framework. Angular ya no es aquel framework monolítico y pesado de los inicios de AngularJS. Con Signals, control de flujo moderno y un soporte LTS robusto, Angular se convirtió en una opción seria para quien quiere una arquitectura sólida sin sacrificar productividad.

En este artículo voy a cubrir desde la trayectoria de Angular hasta las decisiones arquitectónicas concretas que tienen sentido para proyectos reales, incluyendo cómo Signals revolucionaron la reactividad, por qué importa su política LTS y cuándo Angular es la elección correcta frente a alternativas como React.

Requisitos previos

Para aprovechar al máximo este artículo:

  • Familiaridad con TypeScript (tipos básicos, decoradores)
  • Experiencia previa con Angular (cualquier versión ≥ v14) o React; los conceptos comparativos valen para ambos
  • Node.js 18+ o un gestor compatible (Bun, Deno)
  • Comprensión básica de patrones reactivos (observables, promises)

Si eres completamente nuevo en Angular, te sugiero leer primero Começando com Angular: conceitos fundamentais (portugués) antes de abordar este contenido.

Trayectoria de Angular: de NgModule a la era Standalone

Angular nació en 2010 como un proyecto interno de Google. La versión 1.x (AngularJS) fue revolucionaria para su época, pero enfrentó críticas sobre rendimiento y escalabilidad. En 2016, Angular 2 se reescribió desde cero en TypeScript, marcando el punto de ruptura.

Entre 2016 y 2022, el framework evolucionó de forma conservadora: los NgModules eran obligatorios, los cambios breaking eran comunes entre versiones major y la curva de aprendizaje era empinada. Un nuevo proyecto Angular implicaba un boilerplate inevitable.

Todo cambió entre Angular 14 (2022) y 22 (2026). El framework comenzó a converger hacia una arquitectura standalone-first:

  • Angular 14 (2022): Standalone components presentados como experimentales
  • Angular 15 (2022): Standalone se vuelve una opción viable; primera iteración de Signals
  • Angular 16 (2023): Signals estables; hidratación SSR
  • Angular 17 (2023): Nuevo control flow (@if, @switch, @for); standalone como default en ng new
  • Angular 18 (2024): Zoneless tracking en preview; RxJS interop con Signals
  • Angular 19 (2024): Integración más profunda Signals-RxJS
  • Angular 20 (2025): Material design actualizado; refinamientos en la CLI
  • Angular 22 (2026): Signals consolidadas; Zoneless en preview; RxJS interop robusto

Esta trayectoria importa porque explica por qué migrar de v14 a v22 no es trivial: no solo estás actualizando, estás adoptando un nuevo paradigma de reactividad.

Angular 22 en el Contexto Actual: Signals y Reactividad

El mayor cambio de Angular 22 no es una feature aislada; es la reorientación completa de cómo funciona la reactividad.

Históricamente, Angular dependía de los Observables de RxJS como fuente de verdad. Los Observables son poderosos, pero exigen:

  • Declaración de tipos complejos (debounce, switchMap, takeUntil)
  • Una estructura mental basada en streams
  • Cadenas de pipe legibles pero a veces opacas

Signals cambian eso. Un Signal es un primitivo reactivo: un contenedor de valor que notifica a sus subscribers cuando cambia.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import { signal, computed, effect } from '@angular/core';

// Signal básico
const count = signal(0);

// Computed: derivado automáticamente
const doubleCount = computed(() => count() * 2);

// Effect: se ejecuta cuando cambian las dependencias
effect(() => {
  console.log(`Count é agora ${count()}`);
});

// Actualizar es trivial
count.set(5);
count.update(v => v + 1);

Esto es demasiado simple cuando vienes de RxJS. No es magia: es un patrón reactivo limpio sin complejidad innecesaria.

💡 Consejo: Signals no reemplazan a RxJS. Usa RxJS para la complejidad (networking, real-time, debounce). Usa Signals para estado local y UI reactiva simple. Las funciones toSignal() y toObservable() hacen de puente.

En Angular 22, las zonas (Zone.js) empiezan a salir de escena. El framework ahora puede ejecutarse en modo “zoneless”, detectando cambios solo donde cambiaron los Signals, no en toda la app. Esto reduce drásticamente el overhead de la detección de cambios.

Diagrama de la arquitectura de Angular 22 con Components & Templates, Signals & Reactivity y Services & State

Arquitectura de Proyectos Complejos con Angular 22

Cuando escalamos Angular a proyectos con cientos de componentes, las decisiones arquitectónicas importan. Angular 22 ofrece patrones claros:

Estructura recomendada (2026)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
src/
├── app/
│   ├── shared/
│   │   ├── components/        # componentes reutilizables
│   │   ├── directives/
│   │   ├── pipes/
│   │   └── services/          # lógica compartida
│   │
│   ├── core/
│   │   └── services/          # singleton services (auth, http)
│   │
│   ├── features/
│   │   ├── dashboard/
│   │   │   ├── dashboard.component.ts
│   │   │   ├── dashboard.routes.ts
│   │   │   └── services/      # services específicos de la feature
│   │   │
│   │   └── products/
│   │       ├── product-list/
│   │       ├── product-detail/
│   │       └── services/
│   │
│   └── app.config.ts          # configuración global (providersArray)
│
└── main.ts

¿Por qué esta estructura?

  1. Los standalone components (default en Angular 22) viven en la carpeta features, cada uno autocontenido
  2. El lazy loading ocurre mediante la configuración de routing en dashboard.routes.ts
  3. Los shared services centralizan la lógica, evitando duplicación
  4. Los core services son singletons inyectados en la raíz de la app

State Management en Angular 22

Para el estado global, las opciones maduras en 2026:

OpciónCaso de Uso
Signals + ServicesEstado simple/medio; recomendado para nuevos proyectos
NgRx (v17+)Aplicaciones empresariales; flujo unidireccional obligatorio
AkitaAlternativa más simple a NgRx; buena para tamaño medio
MobxReactividad automática; se integra bien con Signals

Para el 90% de los proyectos, Signals en un service singleton es suficiente:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
export class UserService {
  private users = signal<User[]>([]);
  private selectedUser = signal<User | null>(null);

  readonly usersReadonly = users.asReadonly();
  readonly selectedUserReadonly = selectedUser.asReadonly();

  getUsers(): Promise<void> {
    return fetch('/api/users')
      .then(r => r.json())
      .then(data => this.users.set(data));
  }
}

Los componentes inyectan y usan signals de solo lectura, sin acceso directo a la mutación.

Roadmap y Estrategia LTS de Angular

Angular sigue un calendario predecible de releases:

  • Versión major cada 6 meses: marzo y septiembre
  • Versiones activas durante 18 meses: 6 meses de soporte crítico + 12 de LTS

Línea de Tiempo de Soporte (2026)

VersiónReleaseFin ActiveFin LTS
v20Mar 2025Mar 2026Mar 2027
v21Sep 2025Sep 2026Sep 2027
v22Mar 2026Sep 2027Sep 2028
v23Sep 2026Mar 2028Mar 2029

¿Qué significa esto para ti?

Si migras a Angular 22 hoy (junio de 2026), tienes:

  • 1 año y 3 meses de soporte activo (crítico + funcionalidades)
  • 2 años y 3 meses de soporte total (seguridad)
  • Un camino claro hacia v23 en septiembre de 2026

Los proyectos corporativos que ejecutan v20 todavía tienen 9 meses de LTS: tiempo suficiente para planificar la migración sin presión.

ℹ️ Información: El comando ng update en Angular 22 es robusto. Las migraciones entre versiones consecutivas (v21 → v22) generalmente se completan automáticamente con pocas modificaciones manuales.

Comparativa: Angular vs React

Esta es la pregunta que más recibo. No existen respuestas absolutas, pero sí patrones claros.

Filosofía

AspectoAngularReact
AlcanceFramework completo (routing, forms, HTTP, tests)Librería de vistas
ReactividadSignals (primitivos) + RxJS (streams)Hooks + componentes funcionales
State ManagementIntegrado (NgRx, Signals)Externo (Redux, Zustand, Jotai)
Curva de AprendizajeEmpinada; más conceptos de entradaSuave; incremental
Tamaño del Bundle~140 KB (gzip)~40 KB (React puro)
RenderingChange detection automáticoExplícito con useMemo/useCallback

Cuándo Elegir Angular

  1. Proyecto corporativo de larga duración (3+ años)

    • Quieres estabilidad y previsibilidad
    • Un LTS de 18 meses por versión es seguridad
    • TypeScript obligatorio se alinea con el rigor corporativo
  2. Equipo grande, varios equipos

    • Conventions over configuration
    • Estructura de carpetas estándar
    • Menos libertad, menos caos
  3. Aplicación monolítica compleja (dashboard, admin panel)

    • Routing, validación de formularios y HTTP integrados
    • Menos decisiones sobre “qué lib usar”
  4. Real-time / WebSocket-heavy

    • Los Observables de RxJS son naturales para streams
    • Signals + RxJS forman un combo poderoso

Cuándo Elegir React

  1. Prototipado / MVP rápido

    • Curva menor
    • Comunidad enorme
  2. Aplicación pequeña a mediana (single page, landing page)

    • El bundle pequeño importa
    • Simplicidad de JSX
  3. El equipo adora la libertad arquitectónica

    • “Elige tus libs”
    • Personalización radical
  4. Ya dominas React

    • El tiempo de salida al mercado es el factor crítico
    • La experiencia vale más que la tecnología “ideal”

📝 Ejemplo: Veo proyectos React exitosos ejecutando Nextjs + Redux + tRPC con 5 personas, y proyectos Angular igualmente exitosos con equipos de 15. No se trata de tecnología, se trata de alineación.

Comparativa visual entre Angular 22 y React destacando framework completo, Signals, TypeScript y ecosistema

npm, Bun y Deno en el Ecosistema Angular

Un aspecto que suele ignorarse: ¿qué runtime/package manager usar con Angular 22?

npm (Node.js + npm/yarn/pnpm)

  • Maduro: ecosistema estable desde 2009
  • Default: ng new todavía genera para Node.js
  • Bundle: webpack (v5) vía @angular/cli
  • Lock files: package-lock.json, yarn.lock, pnpm-lock.yaml
1
2
3
ng new app-angular-22
npm install
npm start

Recomendación: Mantén npm/pnpm para producción si no tienes un motivo fuerte para cambiar.

Bun (~0.5x más rápido que npm)

  • Rápido: instalación 2-5x más rápida
  • Soporte: Angular 22 funciona con Bun, pero no está oficialmente “probado y validado”
  • Trade-off: Comunidad menor; problemas con ciertos paquetes nativos
1
2
3
4
bun create vite angular-app --template angular-ts
cd angular-app
bun install
bun run dev

Recomendación: Úsalo en dev local. Producción sigue siendo Node.js.

Deno (compatible con Node.js desde 2024)

  • Runtime moderno: sin package.json obligatorio
  • Seguridad: permisos granulares (read, net, env)
  • Soporte: Angular 22 no tiene soporte oficial; tendrías que usar la compatibilidad con Node.js
1
2
// funcionaría vía npm_imports en deno.json
import { bootstrap } from "npm:@angular/platform-browser-dynamic";

Recomendación: Espera. Deno+Angular todavía no está listo para producción en 2026.

Pragmático: Usa npm/pnpm en producción y Bun para dev local si a tu equipo le gusta la velocidad.

CLI y Comandos Esenciales en Angular 22

@angular/cli es tu mejor amigo. Estos son los comandos que realmente importan:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Crear nuevo proyecto (standalone, en TypeScript)
ng new meu-app --create-application

# Generar componente standalone
ng generate component features/dashboard/dashboard --standalone

# Generar service con dependency injection
ng generate service core/services/user

# Ejecutar dev server con cambios en caliente
ng serve --open

# Build optimizado para producción
ng build --configuration production

# Actualizar Angular a una nueva versión
ng update @angular/cli @angular/core

# Ejecutar tests unitarios
ng test

# Lint y fix automático
ng lint --fix

El ng update de Angular 22 es lo bastante robusto para actualizar entre versiones consecutivas de forma casi automática. Prueba siempre en una rama; siempre hay edge cases.

Ejemplo Práctico: Dashboard Reactivo con Signals

Voy a mostrar un ejemplo real que puedes reutilizar: un dashboard simple con estado en Signals, sin NgRx.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
// user.service.ts
import { Injectable, signal } from '@angular/core';

export interface User {
  id: number;
  name: string;
  email: string;
}

@Injectable({ providedIn: 'root' })
export class UserService {
  private usersSignal = signal<User[]>([]);
  private loadingSignal = signal(false);

  readonly users = this.usersSignal.asReadonly();
  readonly loading = this.loadingSignal.asReadonly();

  loadUsers(): void {
    this.loadingSignal.set(true);
    // Simular fetch
    setTimeout(() => {
      this.usersSignal.set([
        { id: 1, name: 'Alice', email: '[email protected]' },
        { id: 2, name: 'Bob', email: '[email protected]' },
      ]);
      this.loadingSignal.set(false);
    }, 1000);
  }
}

// dashboard.component.ts
import { Component, OnInit } from '@angular/core';
import { CommonModule } from '@angular/common';
import { UserService } from '../../core/services/user.service';

@Component({
  selector: 'app-dashboard',
  standalone: true,
  imports: [CommonModule],
  template: `
    <div class="dashboard">
      <h1>Dashboard</h1>
      
      <button (click)="userService.loadUsers()">
        Load Users
      </button>

      @if (userService.loading()) {
        <p>Loading...</p>
      } @else {
        <ul>
          @for (user of userService.users(); track user.id) {
            <li>{{ user.name }} ({{ user.email }})</li>
          }
        </ul>
      }
    </div>
  `,
  styles: [`
    .dashboard { padding: 20px; }
    button { padding: 8px 16px; cursor: pointer; }
  `]
})
export class DashboardComponent implements OnInit {
  constructor(public userService: UserService) {}

  ngOnInit(): void {
    this.userService.loadUsers();
  }
}

Este ejemplo ilustra:

  1. Signal en un service para el estado (usersSignal)
  2. asReadonly() para encapsulamiento
  3. @if / @for, el nuevo control flow
  4. Standalone component (sin NgModule)
  5. CommonModule importado localmente

📂 Código Fuente: Ejemplo completo de la arquitectura recomendada (2026), incluyendo core, shared, features y rutas por módulo: BlogSamples/Frontend/Angular22/Recommended2026/

Consejos y Buenas Prácticas

  1. Empieza con Signals para estado nuevo, no con RxJS de inmediato

    • Signals son más legibles para estado de UI simple. Reserva RxJS para comportamiento complejo (debounce, switchMap). La tendencia es que Signals crezcan; evita deuda técnica de RxJS donde no tiene sentido.
  2. Usa Signals readonly en componentes inyectados

    • Nunca pases signal.set() directamente a componentes hijos. Usa signal.asReadonly() en los services y aísla las mutaciones en métodos. Esto reduce el acoplamiento y los bugs silenciosos.
  3. Haz lazy load de features vía routing

    • Define rutas con loadComponent o loadChildren para cada feature. El bundle se reduce drásticamente. Solo dashboard y auth se cargan al inicio.
  4. Evita cambios breaking entre versiones minor

    • Angular 22.1.x y 22.2.x son backward-compatible. Pero entre v22 → v23 pueden ocurrir breaking changes. Prueba siempre en CI/CD.
  5. RxJS toObservable() en formularios complejos

    • Si tu formulario tiene validación asíncrona o watchers encadenados, convierte Signals en Observables con toObservable(). Los operadores de RxJS (debounceTime, switchMap) encajan de forma natural.

Resumen Objetivo

  • Angular 22 — versión major de marzo de 2026, que consolida Signals como primitivo reactivo estándar, con RxJS integrado para casos complejos y soporte LTS de 18 meses (6 activos + 12 críticos).

  • Signals — contenedores reactivos simples que reemplazan buena parte de RxJS en el código corporativo; signal(), computed() y effect() forman el trío esencial; asReadonly() encapsula la mutación.

  • Standalone Components — patrón por defecto en Angular 22; los NgModules no son obligatorios; cada componente declara sus dependencias mediante imports, reduciendo boilerplate.

  • Arquitectura Recomendada — carpeta features con lazy loading, core services singletons, shared components/pipes; Signals en services para el estado, NgRx/Akita para apps empresariales gigantes.

  • Estrategia LTS — Angular 22 activo hasta septiembre de 2027, LTS hasta septiembre de 2028; ng update automatiza las migraciones entre versiones; los planes corporativos deben usar v20 o v22 ahora.

  • Angular vs React — Angular para proyectos complejos, de largo plazo y con equipos grandes; React para prototipos, MVP y libertad arquitectónica; la tecnología importa menos que la alineación y la experiencia.

  • npm/Bun/Deno — npm/pnpm listos para producción; Bun solo para dev por velocidad; Deno todavía no está listo para Angular.

  • Nuevo Control Flow — @if, @switch, @for reemplazan *ngIf, *ngSwitch, *ngFor; sintaxis más legible y mejor rendimiento en modo zoneless.

Lee También

Referencias