Introducción a Angular y Fundamentos

1

Desarrolla una ToDoApp con Angular y Signals

2

Creando tu primer proyecto en Angular

3

Angular: Componentes y Rutas Básicas

4

Interpolación de Strings en Angular: Uso y Ejemplos Prácticos

5

Enlace de Propiedades HTML con Angular: Guía Práctica

6

Manejo de Eventos Click y Cambios en Angular

7

Eventos de Teclado en JavaScript: Captura y Manejo Eficiente

8

Reactividad granular en Angular: Implementación con Signals

9

Implementación de Reactividad en HTML con Signals

Estructuras de control en Angular

10

Control de Estructuras y Señales en Angular

11

Creación de listas dinámicas con JavaScript

12

Interfaz en TypeScript: Definición y Uso Práctico

13

Actualización de Arrays con Programación Inmutable en Angular

14

Uso de ngIf para Condicionales en Angular

15

Pluralización en Angular: Uso de directivas ngIf y ngSwitch

16

Formularios Reactivos en Angular: Controlando Inputs Eficazmente

17

Validaciones de Formularios en Angular: Control de Inputs

Alistando tu aplicación para producción

18

Integración de SVG en Angular para aplicaciones interactivas

19

Estilización Dinámica con Angular: Clases y Validaciones

20

Edición Dinámica de Tareas con JavaScript y CSS

21

Estados Computados con Signals en Angular

22

Persistencia de datos con localStorage en Angular

23

Compilación Angular: Optimización y Preparación para Producción

24

Despliegue de Aplicaciones en Fibers Hosting

25

Control de Flujo en Angular: Nueva Sintaxis Declarativa

26

Sintaxis de Bucle For en JavaScript Moderno

27

Migración de Sintaxis Angular: de ng-for/ng-if a Nuevas Directivas

Componentes Reutilizables y Comunicación

28

Integración de Tailwind CSS en Proyecto Angular

29

Creación y Gestión de Componentes en Angular

30

Componente Producto en Angular: Renderizado y Reutilización

31

Debugging de Apps Angular con DevTools

32

Inputs en Angular: Comunicación entre Componentes Padre e Hijo

33

Comunicación entre Componentes con Outputs en Angular

34

Maquetación de tiendas online con Tailwind CSS

Ciclo de vida de los componentes

35

Ciclo de Vida de Componentes Angular: Aprende Cada Fase Paso a Paso

36

Desarrollo de Aplicaciones con Angular: Ciclo de Vida de Componentes

37

Ciclo de Vida de Componentes en Angular: ngOnInit y Otros Eventos

38

Validación de cambios en ngOnChanges en Angular

39

Prevención de fugas de memoria con ngOnDestroy en Angular.

40

Uso de WaveSurfer.js para Crear Reproductor de Audio en Angular

41

Curso: Diseño de Interfaz con Tailwind CSS

Mejorando la interfaz del producto

42

Patrones de Diseño y Arquitectura para Aplicaciones Web

43

Creación de un Header Dinámico con Angular

44

Implementación de Side Menu en Carrito de Compras con JavaScript

45

Reactividad y Comunicación entre Componentes en Angular

46

Cálculo Total en Carrito de Compras con Angular Signals

47

Gestión de Estado en Angular: Supera el Problema del InputDrilling

48

Servicio en Angular para Estado Global del Carrito de Compras

49

Inyección de Dependencias en Angular: Uso y Buenas Prácticas

Integración y Datos

50

Conexión a APIs REST con Angular: Obteniendo y Gestionando Datos

51

Alias en TypeScript: Simplificando Imports en Proyectos Grandes

52

Uso de Pipes en Angular: Transformación de Datos Simplificada

53

Creación de Pipes Personalizados en Angular

54

Manipulación de Fechas con Date Functions en Angular

55

Directivas en Angular: Manipulación Directa del DOM

56

Despliegue de Aplicaciones Angular en Vercel: Guía Completa

Enrutamiento y Navegación

57

Página personalizable 404 con Angular: Guía paso a paso

58

Redirección con Router Link en Angular: Flujo sin Recarga Total

59

Uso de Layouts Compartidos en Angular para Estructura Sostenible

60

Uso de RouterLinkActive en Angular para Rutas Activas

61

Routing en Angular: Parámetros de URL para Detalle de Productos

62

Detalles y Renderizado de Producto con Angular

63

Galería de Imágenes Dinámica con Angular

64

Conexión de Servicios en Angular: Moneda, Carrito y Galería

Perfeccionando tu e-commerce

65

Filtrado de Productos por Categoría en Angular

66

Filtrado dinámico de productos con query params en Angular

67

Lazy Loading y Code Splitting en Aplicaciones Angular

68

Optimización de JavaScript con Dynamic Imports en Angular

69

Optimizar Angular: Preloading para Mejorar Carga en Redes Lentas

70

Migración a la Nueva Sintaxis de Angular Step-by-Step

71

Despliegue de Aplicaciones Web con Verzal Paso a Paso

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Pluralización en Angular: Uso de directivas ngIf y ngSwitch

15/71
Recursos

¿Cómo implementar la pluralización en Angular con ngIf?

La pluralización es un problema común al mostrar elementos en una lista, pero en Angular podemos usar el control estructural ngIf para solucionarlo de manera efectiva. Se trata de mostrar una palabra en su forma singular o plural dependiendo de la cantidad de elementos que estamos iterando.

  1. Organización del componente: Primero, debemos identificar claramente dónde se encuentra nuestro componente de conteo de tareas. Dentro de este componente, encontramos el número de elementos seguido de la palabra "items". Aquí es donde implementaremos ngIf.

  2. Uso de span y ngTemplate: Lo ideal es situar la palabra "item" dentro de un nuevo elemento, como por ejemplo un <span>. Luego, crea una estructura de control else utilizando ngTemplate para establecer la palabra en su forma plural "items".

  3. Implementación del ngIf:

    • Define tu condicional con ngIf para mostrar la forma singular si el tamaño de las tareas, es decir, tasks.length, es igual a 1.
    • Utiliza else para el bloque alternativo que se mostrará cuando haya más de un elemento.
<span *ngIf="tasks.length === 1; else elseBlock">item</span>
<ng-template #elseBlock>items</ng-template>
  1. Prueba de la pluralización: Al agregar o remover tareas, observa que la singularidad o pluralidad de la palabra cambia dinámicamente. Este enfoque es práctico, pero si requieres gestionar múltiples condiciones, como manejar varios ngIf para diferentes casos, puede ser mejor adoptar otra estrategia más mantenible con ngSwitch.

¿Qué es ngSwitch y cómo facilita el código?

Cuando se tiene una gran cantidad de condicionales if basados en un único atributo, ngSwitch resulta ser una herramienta poderosa y más comprensible. Esta directiva permite manejar múltiples condiciones de manera centralizada y clara.

  1. Estructura básica de ngSwitch:
    • Define un div con ngSwitch, que se suscribe a un atributo específico. Usa ngSwitchCase para establecer los valores específicos que se deben evaluar.
    • Utiliza ngSwitchDefault para definir un caso por defecto, que se mostrará cuando ninguna condición se cumpla.
<div [ngSwitch]="person.name">
  <span *ngSwitchCase="'Nicolás'">Yo soy Nicolás</span>
  <span *ngSwitchCase="'Julián'">Yo soy Julián</span>
  <span *ngSwitchCase="'Ana'">Yo soy Ana</span>
  <span *ngSwitchCase="'Valentina'">Yo soy Valentina</span>
  <span *ngSwitchDefault>Yo no soy nadie</span>
</div>
  1. Ventajas del ngSwitch:

    • Simplifica el código al reunir varias condiciones bajo un solo control estructural.
    • Hace el código más legible y fácil de mantener, especialmente cuando se compara con múltiples estructuras ngIf.
    • Ofrece un mecanismo central para manejar casos que no encajen con ninguna condición mediante ngSwitchDefault.
  2. Comportamiento reactivo: Para que la visualización sea dinámica al cambiar el nombre de una persona, puedes utilizar un input que actualice el atributo de name de manera reactiva.

<input [(ngModel)]="person.name" />

¿Cómo potenciar interactividad con inputs y eventos?

Integrar elementos interactivos, como inputs, en tus aplicaciones de Angular puede aumentar la usabilidad y la experiencia del usuario.

  1. Implementar inputs reactivos: El uso de [(ngModel)] permite actualizar datos en tiempo real. Asegúrate de tener predefinido el modelo y que los datos del input se enlacen correctamente a las propiedades del componente.

  2. Actualizar propiedades dinámicamente: Al introducir cambios en el input, el valor del nombre cambia, interactuando con el ngSwitch.

changeName(newName: string) {
  this.person.name = newName;
}
  1. Interactividad fluida: La clave está en crear métodos que respondan a las interacciones del usuario, haciendo que la interfaz sea intuitiva y el contenido dinámico. Observa el cambio inmediato al pulsar enter, autoactualizando cada cambio de nombre.

Con conocimientos de ngIf, ngSwitch, y manejo de inputs, puedes crear aplicaciones Angular más dinámicas y mantenibles. Estos conceptos te permitirán mejorar tanto la lógica de negocio como la experiencia de usuario en tus desarrollos. ¡Sigue aprendiendo y explorando nuevas funcionalidades para potenciar tus habilidades de desarrollo!

Aportes 30

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

![](https://static.platzi.com/media/user_upload/image-085600c3-1320-4baa-9fe2-9feca0163058.jpg)
![](https://static.platzi.com/media/user_upload/image-b81abe25-3891-4561-a1cd-6e244c89c401.jpg)![]()
yo resolví este reto solo agrgeando un span con la letra s y mostrandolo con if que evalué que si el array es mayor que 1 `{{ tasks().length }} items `
Con un one line if statement, se resuelve ![](https://static.platzi.com/media/user_upload/image-e742bfd1-5da1-4027-9b06-decd89dd5973.jpg)
Comparto mi aporte de switch usando angular 19 ```ts
@switch (person().name) { @case ('John') {

Yo soy john

} @case ('Cesar') {

Yo soy cesar

} @case ('jose') {

Yo soy jose

} @default {

no soy nadie

} }
```\
    @switch (person().name) {      @case ('John') {        \

Yo soy john\

      }      @case ('Cesar') {        \

Yo soy cesar\

      }      @case ('jose') {        \

Yo soy jose\

      }      @default {        \

no soy nadie\

      }    }  \
![](https://static.platzi.com/media/user_upload/image-c8a036bf-8006-4208-919f-fc6ec6b3366f.jpg)
![](https://static.platzi.com/media/user_upload/image-e903e350-3bf7-4a00-93a3-15428d955107.jpg)
La verdad usé ternaries porqué está feo con el ngIf jajajajajaja
esta fue mi solución  \           \{{tasks().length}}\           \<ng-container \*ngIf="tasks().length > 1; else elseblock">items\</ng-container>                  \         \<ng-template #elseblock>item\</ng-template> obviamente se podría ocupar el operador ternario pero perderia el enfoque de la practica. Igualmente el ngfor ya no se usa mucho si no se remplaza por el @for (item of items; track item.name) { \
  • {{ item.name }}\
  • } @empty { \
  • There are no items.\
  • }
    Importante resaltar que este caso no sera aislado sino que se repetirá a lo largo de nuestra aplicación así que hay que pensar en la extensibilidad y tener una forma en la que se pueda reusar y no tener un montón de fragmentos haciendo lo mismo
    ```js const SINGULAR = 1; const showPluralWhenMultipleElementsFor = (elementsGroup) => { return `item${elementsGroup.length > SINGULAR ? "s" : ""}` }; {{ tasks().length }} {{ showPluralWhenMultipleElementsFor(tasks()) }} left ```const SINGULAR = 1; const showPluralWhenMultipleElementsFor = (elementsGroup) => { return `item${elementsGroup.length > SINGULAR ? "s" : ""}` }; \ \{{ tasks().length }}\ {{ showPluralWhenMultipleElementsFor(tasks()) }} left \
    La solución del reto de la clase anterior fue igual al que yo envié 🥳
    El uso de `ngSwitch` y `ngSwitchDefault` en Angular es una forma eficiente de manejar múltiples condiciones. `ngSwitch` permite evaluar un único valor y seleccionar un caso específico mediante `ngSwitchCase`, facilitando la lectura del código en comparación con múltiples `ngIf`. Cuando la expresión no coincide con ningún caso, `ngSwitchDefault` se activa, permitiendo manejar situaciones donde no hay coincidencias. Este enfoque es más limpio y mantenible cuando se tienen varias condiciones relacionadas con un mismo atributo, mejorando la estructura del código.
    Aca esta mi codigo implementando ngSwitch  \
      \<input type="text" \[value]="persona.nombre" (change)="cambiaNombre($event)" /> \
    \

    soy juan\

    \

    soy toro\

    \

    soy luis\

    \

    no soy ninguno\

     \
    Esta fue mi solución, un poco mas larga pero funciona de la misma manera \\{{ tasks().length }}\ items left\        \<ng-template #elseblock >          \\{{ tasks().length }}\ item left\        \</ng-template>
    Pregunta: Tengo entendido que para temas de SEO, es positivo tener etiquetas variadas es decir: \ \
    \ \
      \
    • (y sus respectivas closing tags) porque si repites varias veces la misma etiqueta, esto lo castiga el navegador. ¿Este beneficio también se obtiene con la etiqueta \<ng-template> \</ng-template>? ¿Qué tipo de etiqueta se vuelve \<ng-template> \</ng-template>? Por ejemplo, si utilizas en react \<React.Fragment>, me parece que se vuelve un nodo vacío en el DOM, lo cuál es bueno si no quieres que tenga las propiedades de una etiqueta que pueden dañar cómo se visualiza el css en tu desarrollo.
    Profe, me gustó más su respuesta pero utilicé el operador !== ya que cuando el item es cero (zero en inglés), comúnmente se diría "items": ```js {{ tasks().length }} <ng-template [ngIf]="tasks().length !== 1" [ngIfElse]="individualTask"> items </ng-template> <ng-template #individualTask> item </ng-template> ```
    si es un proyecto !== legacy mejor usa directivas <https://v17.angular.io/api/core/switch> @switch (condition) { @case (caseA) { Case A. } @case (caseB) { Case B. } @default { Default case. } `}`
    enserio que con directivas se ahorra uno mucho codigo: \\{{ tasks().length }}\ item@if (tasks().length>1) {s} left\
    ![](https://static.platzi.com/media/user_upload/image-fce97ae7-65b5-429a-b081-c8d8694306a9.jpg)
    ```html {{toDo().length}} items left <ng-template #item> {{toDo().length}} item left </ng-template> ```
    la solución del ejercicio anterior \
            \\{{tasks().length}}\          item\      \
          \<ng-template #itemsNotification>        \\{{tasks().length}}\ items\      \</ng-template>
    ```html \ \{{tasks().length}} \ @if (tasks().length <= 1){item}@else{items} left \ ```
    Lo resolvi as\[i \          \{{ tasks().length }}\           item\s\ left        \

    Mi codigo:
    <span class=“todo-count”><strong *ngIf=“tasks().length > 1; else item”> {{tasks().length}} items</strong></span>
    <ng-template #item>{{tasks().length}} item</ng-template>

    ```html {{ tasks().length }} items left <ng-template #lowerThanOne> 1 item left </ng-template> ```
    ```js {{tasks().length}} {{(tasks().length > 1 ? 'items' : 'item')}} ```Con una ternaria también se puede solucionar
    ```js {{tasks().length}} {{(tasks().length > 1 ? 'items' : 'item')}} ``` \\{{tasks().length}}\ {{(tasks().length > 1 ? 'items' : 'item')}}\