Modificación de Inputs en Angular con Setters y Ciclo de Vida
Curso de Angular Forms: Creación y Optimización de Formularios Web
Contenido del curso
Primeros pasos con Angular Forms
- 5

Ventajas de los Formularios Reactivos en Angular
01:32 min - 6

For Control en Formularios Reactivos: Creación y Uso Básico
17:16 min - 7

Tipos de Input en HTML y su Impacto en la Experiencia de Usuario
08:12 min - 8

Uso de Selects y Selectores Múltiples en Formularios HTML
06:59 min - 9

Implementación de Inputs Radio y Checkbox en Formularios HTML
09:20 min - 10

Validaciones en Formularios con Angular: Sincronización y Estados
12:15 min - 11

Integración de CSS Dinámico en Formularios Reactivos con Angular
12:42 min
Descubre todas las validaciones de Angular Forms
- 12

Manejo de formularios reactivos con FormGroup en Angular
10:00 min - 13

Creación de Formularios Reactivos con FormBuilder en Angular
12:25 min - 14

Validaciones en Angular: 11 Métodos y Expresiones Regulares
13:40 min - 15

Manejo de FormGroups Anidados en Formularios Angular
09:23 min - 16

Implementación de Formularios con Angular Material
14:31 min - 17

Errores Comunes en Formularios Angular Material
05:26 min - 18

Validaciones Personalizadas de Contraseñas en Angular
15:22 min
Implemeta validaciones avanzadas en PlatziStore
- 19

Validaciones Grupales en Formularios Reactivos de Angular
10:11 min - 20

Validaciones Condicionadas en Formularios Reactivos
09:09 min - 21

Gestión de Categorías en Angular: Creación y Edición de Formularios
06:32 min - 22

Conexión de una API REST con Angular y Postman
15:47 min - 23

Subir Imágenes a FiberStorage con Angular y HTML
12:35 min - 24

Validaciones Asíncronas con API para Formularios de Categorías
17:55 min - 25

Edición de Categorías con Patch Value en Angular
11:16 min - 26

Editar y Crear Categorías con un Solo Formulario
06:01 min
Construye formularios dinámicos conectando una API
- 27

Patrón Smart y DOM Components en Formularios Angular
17:01 min - 28

Modificación de Inputs en Angular con Setters y Ciclo de Vida
Viendo ahora - 29

"Mejoras en Formularios y Validaciones de Productos"
10:13 min - 30

Select dinámico con Angular y API de categorías
12:17 min - 31

Select dinámico con objetos en Angular y Angular Material
07:45 min - 32

Creación de Formularios Dinámicos con Reactive Forms en Angular
15:35 min
Estrategias avanzadas y optimización de formularios
- 33

Conexión de Componentes Propios a Reactive Forms en Angular
19:40 min - 34

Optimización de búsquedas con NGRX y HTTP en Angular
15:46 min - 35

Optimización de Búsquedas con Debounce Time en Angular
06:47 min - 36

Fundamentos de Accesibilidad Web para Desarrolladores
07:01 min - 37

Rendimiento y Optimización en Aplicaciones Angular
01:27 min
Modificación de Inputs en Angular con Setters y Ciclo de Vida
Resumen
Implementar el patrón de smart and dumb components en Angular trae beneficios claros en separación de responsabilidades, pero también introduce retos concretos cuando la información que fluye entre componentes es asíncrona. Aquí se aborda cómo resolver uno de los problemas más comunes: que el formulario no se rellene correctamente al editar, y la solución elegante que ofrece usar un setter en el input del componente.
¿Por qué el formulario no se rellena al editar con smart and dumb components?
Al separar responsabilidades, el smart component se encarga de obtener la categoría desde el servidor y enviarla al dumb component mediante un input. Sin embargo, al migrar la lógica de patchValue fuera del componente inteligente, el formulario deja de recibir los datos para rellenarse [01:06].
El problema es claro: el input recibe la categoría, pero en ningún momento se ejecuta un patchValue que lleve esa información al formulario. Simplemente se recibe el dato y se usa para validaciones visuales, no para poblar los campos.
¿Se puede usar el constructor o ngOnInit para resolver esto?
- Constructor: no es viable porque la categoría llega de forma asíncrona, es decir, puede aparecer mucho después de que el componente ya fue construido [02:06].
- ngOnInit: tampoco resuelve el problema. Se ejecuta solo una vez y, normalmente, el componente se monta antes de que el fetch de la categoría haya terminado [02:18].
- ngDoCheck: es otra opción disponible en Angular, pero no es la más recomendada para este caso.
La solución más precisa es convertir el input en un setter [02:32].
¿Cómo funciona un setter en un input de Angular?
Así como existen getters, también existen setters. Al definir el input como un set, se obtiene el momento exacto en que la información llega al componente, sin importar si es asíncrona o no [02:42].
typescript @Input() set category(data: Category) { if (data) { this.form.patchValue(data); this.isNew = false; } }
- Si
dataexiste, se ejecutapatchValuepara llenar el formulario y se marcaisNewcomofalse. - Si no llega información,
isNewpermanece entruepor defecto, indicando que se trata de una creación.
Esta variable isNew de tipo boolean reemplaza la referencia directa a category en el template, ya que al convertir el input en un método, deja de comportarse como una variable con estado [03:22].
¿Cómo impacta el setter en la lógica de guardado y en el template?
Con la bandera isNew disponible, la lógica del método save se simplifica [05:28]:
- Si
isNewestrue, se ejecuta la creación. - Si
isNewesfalse, se ejecuta la actualización.
En el HTML del dumb component, el texto del botón cambia dinámicamente: muestra "crear" cuando isNew es verdadero y "editar" cuando es falso [04:08].
html <button>{{ isNew ? 'Crear' : 'Editar' }}</button>
¿Qué ventajas ofrece esta técnica en el ciclo de vida de Angular?
Usar un setter en el input garantiza varias cosas importantes [04:24]:
- Se conoce el momento exacto en que llega la información.
- El componente ya pasó por su ciclo de
constructoryngOnInit, por lo que se pueden usar con confianza métodos e instancias declaradas. - Se evitan errores derivados de datos nulos o inválidos gracias a la validación dentro del setter.
Es fundamental mantener la calma al encontrar errores durante estos cambios. Leer con atención los mensajes de la consola y aplicar correcciones de forma pausada es parte natural del proceso de refactorización [05:50].
El patrón de smart and dumb components combinado con setters en los inputs es una estrategia de arquitectura muy valorada profesionalmente. Dominar esta técnica permite construir componentes más predecibles, mantenibles y con responsabilidades bien definidas. Si ya lo implementaste, cuéntanos cómo te fue en los comentarios.