Front-end8 min de lectura
Angular Standalone Components: qué son y cómo migrar
Qué son los standalone components en Angular y cómo migrar un proyecto con NgModule: el schematic oficial, las rutas con loadComponent, bootstrapApplication e inject().

Si trabajas con Angular desde hace un tiempo, conoces el ritual: creaste un componente, tienes que declararlo en un NgModule, importar el módulo en otro módulo, exportarlo para que alguien lo use... y cuando algo no aparece en pantalla, la culpa casi siempre es de un módulo que faltó importar.
Los standalone components acaban con ese ritual. Cada componente dice por sí solo lo que necesita, y el NgModule deja de ser obligatorio.
Publiqué la primera versión de este post en Medium en 2023, en portugués, y se convirtió en mi texto más leído allí. Esta es la versión revisada: el código salió de las capturas y se volvió texto que puedes copiar, corregí dos errores que estaban en el original y actualicé lo que cambió en Angular desde entonces.
Los ejemplos de migración vienen de angular-shop, el proyecto de demostración de Loiane Groner con las novedades de Angular.
TL;DR#
- Un standalone component es un componente que declara sus propias dependencias en el
importsdel@Component, sin necesitar unNgModule. - Desde Angular 19 es el estándar: todo componente nuevo ya nace standalone. Para que un componente antiguo siga dependiendo de un módulo, necesita
standalone: false. - La migración es automática en tres pasos:
ng generate @angular/core:standalone, ejecutado tres veces, una por cada modo, compilando entre uno y otro. - Las rutas las migras a mano: cada
*-routing.module.tsse convierte en un arrayRoutesexportado, cargado conloadChildreno, si es un solo componente, conloadComponent. bootstrapApplicationreemplaza alAppModule, y los providers se vuelven funciones:provideRouter,provideHttpClient.inject()no depende de standalone. Funciona en cualquier clase creada por la inyección de dependencias y tiene su propio schematic para migrar.
Qué es un standalone component#
Antes, un componente solo existía dentro de un módulo. El módulo era el que decía lo que el componente podía usar:
// before: the module declares the component and imports what it needs
@NgModule({
declarations: [CartComponent],
imports: [CommonModule, RouterModule],
})
export class CartModule {}Un standalone component lleva esa lista dentro de sí mismo:
// after: the component imports its own dependencies
@Component({
selector: 'app-cart',
imports: [CurrencyPipe, RouterLink],
templateUrl: './cart.component.html',
})
export class CartComponent {}Fíjate que no hay standalone: true. Hasta Angular 18 tenías que escribir esa línea. A partir de Angular 19, standalone es el estándar, y es el componente que todavía depende de un módulo el que tiene que avisar, con standalone: false.
En la práctica, esto cambia tres cosas:
- Queda claro de qué depende el componente. Abres el archivo y la lista está ahí, no repartida entre módulos.
- El lazy loading se vuelve más fino. Puedes cargar un solo componente en una ruta, sin crear un módulo solo para eso.
- Menos archivos que mantener. Desaparece el
cart.module.ts, desaparece elcart-routing.module.ts.
Y no hace falta migrar todo de una vez: componentes standalone y módulos conviven en el mismo proyecto. Un standalone puede importarse en un NgModule, y un módulo puede entrar en el imports de un standalone.
Migrando con el schematic oficial#
Angular tiene un schematic que hace la mayor parte del trabajo. Antes de ejecutarlo, la guía oficial pide tres cosas:
- que el proyecto esté en Angular 15.2 o más reciente;
- que el proyecto compile sin errores;
- estar en una rama limpia de Git, con todo commiteado. Así, si la migración hace un desastre, un
git restore .lo deshace.
El comando es uno solo:
ng generate @angular/core:standaloneTe pregunta qué modo ejecutar. Ejecuta los tres, en este orden, compilando y probando la app entre uno y otro:
- "Convert all components, directives and pipes to standalone": convierte cada componente, directiva y pipe en standalone y llena el
importsde cada uno con lo que usa. - "Remove unnecessary NgModule classes": borra los módulos que quedaron vacíos. Lo que no consiga borrar solo, lo marca con un comentario
TODO(standalone-migration)para que lo resuelvas tú. - "Bootstrap the application using standalone APIs": cambia el
bootstrapModule(AppModule)delmain.tsporbootstrapApplication.
En un proyecto grande, puedes ir por partes con la opción --path, migrando una carpeta a la vez:
ng generate @angular/core:standalone --path src/app/cartDespués de los tres pasos, la propia guía sugiere una limpieza:
- busca los
NgModuleque sobraron y borra a mano lo que puedas; - ejecuta los tests unitarios y corrige lo que se rompió;
- ejecuta el formateador y el linter, porque el código generado no siempre sigue el estilo del proyecto.
Convirtiendo las rutas#
Después del schematic, los módulos de funcionalidad (como el CartModule y el ProductsModule) muchas veces siguen existiendo, solo para cargar las rutas. Esa parte el schematic de standalone no la hace, así que te toca a ti. La buena noticia: es la parte más sencilla.
El módulo de rutas se convierte en un array#
Antes, cada funcionalidad tenía un módulo solo para registrar las rutas:
// cart-routing.module.ts (before)
import { NgModule } from '@angular/core'
import { RouterModule, Routes } from '@angular/router'
import { CartComponent } from './cart/cart.component'
const routes: Routes = [{ path: '', component: CartComponent }]
@NgModule({
imports: [RouterModule.forChild(routes)],
exports: [RouterModule],
})
export class CartRoutingModule {}Después, es solo el array, exportado:
// cart.routes.ts (after)
import { Routes } from '@angular/router'
import { CartComponent } from './cart/cart.component'
export const CART_ROUTES: Routes = [{ path: '', component: CartComponent }]Lo mismo para productos:
// products.routes.ts (after)
import { Routes } from '@angular/router'
import { ProductFormComponent } from './product-form/product-form.component'
import { ProductsListComponent } from './products-list/products-list.component'
export const PRODUCTS_ROUTES: Routes = [
{ path: '', component: ProductsListComponent },
{ path: 'new', component: ProductFormComponent },
]En la primera versión de este post, el
products.routes.tsexportabaCART_ROUTES(lo copié del archivo del carrito y olvidé cambiarlo), mientras que las rutas principales importaban otro nombre. Tal como estaba, el código ni compilaba. Aquí el nombre es uno solo:PRODUCTS_ROUTES.
Las rutas principales apuntan a los arrays#
En el app-routing.module.ts, el loadChildren cargaba un módulo:
// app-routing.module.ts (before)
const routes: Routes = [
{ path: '', pathMatch: 'full', redirectTo: 'products' },
{
path: 'products',
loadChildren: () => import('./products/products.module').then((m) => m.ProductsModule),
},
{
path: 'cart',
loadChildren: () => import('./cart/cart.module').then((m) => m.CartModule),
},
]
@NgModule({
imports: [RouterModule.forRoot(routes)],
exports: [RouterModule],
})
export class AppRoutingModule {}Ahora carga el array de rutas. El lazy loading sigue igual: el código de productos solo se descarga cuando alguien entra en /products.
// app.routes.ts (after)
import { Routes } from '@angular/router'
export const APP_ROUTES: Routes = [
{ path: '', pathMatch: 'full', redirectTo: 'products' },
{
path: 'products',
loadChildren: () => import('./products/products.routes').then((m) => m.PRODUCTS_ROUTES),
},
{
path: 'cart',
loadChildren: () => import('./cart/cart.routes').then((m) => m.CART_ROUTES),
},
]Una ruta, un componente: loadComponent#
El carrito tiene una sola ruta. No necesita un archivo de rutas: con loadComponent, la ruta carga el componente directamente, y el cart.routes.ts se puede borrar.
// app.routes.ts
{
path: 'cart',
loadComponent: () => import('./cart/cart/cart.component').then((m) => m.CartComponent),
}Y si el archivo usa export default, ni siquiera hace falta el .then:
// cart.component.ts: export default class CartComponent {}
{
path: 'cart',
loadComponent: () => import('./cart/cart/cart.component'),
}El loadChildren acepta el mismo atajo cuando el archivo de rutas tiene export default.
¿Tienes rutas cargando componentes directamente, sin lazy loading, y quieres cambiarlas todas de una vez? Hay otro schematic para eso:
ng generate @angular/core:route-lazy-loadingcambia elcomponentporloadComponenten las rutas que encuentre.
El main.ts sin AppModule#
El tercer paso del schematic ya cambia el bootstrap a bootstrapApplication. Pero, si el proyecto tenía un AppRoutingModule, suele quedar dentro del importProvidersFrom, todavía como módulo:
// main.ts (before)
bootstrapApplication(AppComponent, {
providers: [
importProvidersFrom(BrowserModule, AppRoutingModule),
provideHttpClient(withInterceptorsFromDi()),
],
})Cambia el módulo de rutas por provideRouter, con el array:
// main.ts (after)
import { bootstrapApplication } from '@angular/platform-browser'
import { provideHttpClient, withInterceptorsFromDi } from '@angular/common/http'
import { provideRouter } from '@angular/router'
import { AppComponent } from './app/app.component'
import { APP_ROUTES } from './app/app.routes'
bootstrapApplication(AppComponent, {
providers: [provideRouter(APP_ROUTES), provideHttpClient(withInterceptorsFromDi())],
})El BrowserModule también puede salir: bootstrapApplication ya trae lo que él hacía. Con eso, puedes borrar con seguridad:
app-routing.module.ts,cart-routing.module.tsyproducts-routing.module.ts;cart.module.tsyproducts.module.ts, si el schematic todavía no los borró.
La función inject()#
En el original presenté inject() como una "nueva opción con standalone components". No tiene nada que ver con standalone. Desde Angular 14, inject() funciona en cualquier clase que crea la inyección de dependencias (componente, directiva, pipe, servicio), con o sin módulo. Solo apareció junto porque los dos llegaron más o menos en la misma época.
Lo que hace: busca una dependencia en el inyector activo, sin necesitar el constructor.
// constructor injection
export class ProductsListComponent {
constructor(
private service: ProductsService,
private cartService: CartService,
) {}
}
// with inject()
export class ProductsListComponent {
private service = inject(ProductsService)
private cartService = inject(CartService)
}¿Por qué preferirlo? El código queda más corto, los tipos quedan más precisos (según la propia documentación, también combina mejor con los decorators estándar de JavaScript), y además funciona en funciones, como un guard de ruta funcional. La única regla es llamar a inject() en un contexto de inyección: en el constructor, en la inicialización de un campo de la clase o en una función que Angular llama en ese contexto (como guards y resolvers). En un setTimeout o en un clic, da error.
Y hay un schematic para convertirlo todo:
ng generate @angular/core:injectConclusión#
Los standalone components dejan a cada componente a cargo de sus propias dependencias, y eso hace que el proyecto sea más fácil de leer, de dividir y de cargar de a poco. Con el schematic, la parte aburrida de la migración es automática. Lo que te queda son las rutas y el main.ts, y es poca cosa.
Si tu proyecto todavía está lleno de NgModule, el camino es: rama limpia, los tres modos del schematic con un build entre ellos, rutas a mano y después ng generate @angular/core:inject para cerrar.
Referencias#
Sigue leyendo

Front-end17 min de lectura
SEO multilingüe en React: hreflang, prerender y sitemap

Front-end15 min de lectura
Cómo creo videos con IA usando Remotion: un caso real

Front-end16 min de lectura
Cómo compartir contraseñas de forma segura: Yush por dentro