Introducción a Angular y Fundamentos

1

Aprende Angular 17

2

Creando tu primer proyecto en Angular

3

Implementando estilos

4

Mostrando elementos

5

Property Binding en Angular

6

Event Binding: click y doble click

7

Event binding: keydown

8

Modelo de reactividad con Signals

9

Creando un Signal en Angular

Estructuras de control en Angular

10

Directivas de control

11

Uso de ngFor

12

ngFor para objetos

13

Update Tasks

14

Uso de ngIf

15

Uso de ngSwitch y ngSwitchDefault

16

Controlando un input

17

Manejo de formularios en Angular

Alistando tu aplicación para producción

18

Estilos al modo Angular

19

Clases en Angular

20

Editing mode

21

Estados compuestos con computed

22

Usando effect para localStorage

23

Uso de ngbuild

24

Despliegue con Firebase Hosting

25

Nueva sintaxis en Angular

26

Directivas @For, @switch

27

Migrando a la nueva sintaxis de Angular v17

Componentes Reutilizables y Comunicación

28

Construyendo un e-commerce en Angular

29

Componentes en Angular

30

Mostrando los componentes

31

Angular DevTools

32

Uso de Inputs en Angular

33

Uso de Outputs en Angular

34

Componentes para Producto

Ciclo de vida de los componentes

35

Ciclo de vida de componentes

36

Ciclo de vida de componentes: ngOnChanges

37

Ciclo de vida de componentes: ngOnInit

38

Detectando cambios en los inputs

39

Evitando memory leaks con ngDestroy

40

Audio player con ngAfterViewInit

41

Creando la página "about us" o "conócenos"

Mejorando la interfaz del producto

42

Creando componente de productos

43

Creando el Header

44

Creando el carrito de compras

45

Comunicación padre e hijo

46

Calculando el total con ngOnChanges

47

El problema del prop drilling

48

Reactividad con signals en servicios

49

Entendiendo la inyección de dependencias

Integración y Datos

50

Obteniendo datos una REST API

51

Importaciones cortas en Typescript

52

Pipes en Angular

53

Construyendo tu propio pipe

54

Utilizando librerías de JavaScript en Angular

55

Conociendo las directivas

56

Deployando un proyecto en Vercel

Enrutamiento y Navegación

57

Ruta 404

58

Uso del RouterLink

59

Vistas anidadas

60

Uso del RouterLinkActive

61

Detalle de cada producto

62

Obteniendo datos del producto

63

Galería de imagenes

64

Detalle de la galería

Perfeccionando tu e-commerce

65

Mostrando categorias desde la API

66

Url Params

67

LazyLoading y Code Splitting

68

Aplicando LazyLoading

69

Prefetching

70

Usando la nueva sintaxis de Angular 17

71

Lanzando tu aplicación a producción

No tienes acceso a esta clase

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

Uso de ngIf

14/71
Recursos

¿Cómo utilizar ng-if en Angular?

El ng-for en Angular te permite iterar sobre elementos, pero en ocasiones es fundamental controlar la renderización de elementos según ciertas condiciones. Aquí es donde entra el ng-if como estructura de control. Descubre cómo utilizar esta poderosa herramienta para manipular de manera dinámica tus componentes en Angular.

¿Qué es ng-if y cómo funciona?

El ng-if es un condicional en Angular que decide si un elemento debe ser renderizado o no. A diferencia de simplemente ocultar un elemento, si la condición del ng-if no se cumple, el elemento no será generado en el DOM. Veamos cómo implementarlo con un ejemplo sencillo:

<div *ngIf="1 === 1">
  Este contenido se muestra porque la condición se cumple.
</div>

Si la condición 1 === 1 es verdadera, el div se renderiza. Si cambiamos la condición a algo falso como 1 === 2, el div simplemente no aparecerá.

¿Cómo manejar condicionales más complejas?

Además de las condiciones simples, el ng-if permite usar expresiones complejas y anidaciones para crear lógica más rica. Supongamos que tienes una señal name y quieres renderizar contenido solo si el valor es "Nicolás":

<div *ngIf="name() === 'Nicolás'">
  Soy Nicolás
</div>

Es crucial recordar que estas comparaciones son case sensitive, por lo que "nicolás" no se consideraría igual a "Nicolás".

¿Cómo trabajar con objetos y señales?

Supongamos que tienes un objeto person con atributos, y quieras que su renderización responda de forma reactiva a sus valores. Convertimos el objeto en una señal y lo utilizamos en una condición:

const personSignal = signal({
  name: 'Nicolás',
  age: 20
});

<div *ngIf="personSignal().name === 'Nicolás' && personSignal().age > 18">
  Soy Nicolás y soy mayor de 18
</div>

Aquí, el contenido solo se renderizará si el nombre es "Nicolás" y la edad es mayor a 18.

¿Cómo implementar un else en ng-if?

Angular también permite manejar un else utilizando ng-template. Es decir, si la primera condición no se cumple, puedes definir qué contenido se mostrará:

<div *ngIf="condition; else elseBlock">
  Esta es la condición verdadera.
</div>
<ng-template #elseBlock>
  Esta es la condición falsa.
</ng-template>

Puedes modificar el contenido del else cambiando el nombre del bloque como requieras, utilizando #nombreDelBloque.

¿Cómo hacer adaptativo el contenido de ng-if?

Para hacer el contenido dinámico y reactivo, podemos enlazarlo a un input. Adicionalmente, para manejar la pluralización basada en la cantidad de elementos en una lista:

<!-- Input para modificar la edad -->
<input type="number" (change)="changeAge($event)">

<!-- Control de pluralización -->
<div *ngIf="items.length > 1">
  {{ items.length }} items
</div>
<div *ngIf="items.length === 1">
  1 item
</div>

Implementar la lógica de pluralización correctamente es un reto común. Intenta resolverlo evaluando el número de elementos en tu array y ajustando el texto para que corresponda en singular o plural.

A medida que domines estas herramientas, podrás crear aplicaciones Angular más dinámicas y efectivas. ¡Sigue experimentando y aprendiendo con las múltiples posibilidades que Angular te ofrece!

Aportes 69

Preguntas 0

Ordenar por:

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

Esta sería mi forma de solucionar la misión de la clase 🫡.

<span class="todo-count"
  ><strong>{{ tasks().length }}</strong>
  {{ tasks().length <= 1 ? "item" : "items" }} left</span
>

Para convertir un string a number yo generalmente hago lo siguiente, antepongo el signo mas y listo, como podrás ver a continuación:

this.inputTask = +this.inputTask

Asi fue como lo solucione

<span class="todo-count">
        <strong>{{ tasks().length }}</strong>
        {{ tasks().length === 1 ? 'item' : 'items' }}
      </span>
esta es mi solución la hice lo más sencilla posible sin perder de vista el \*ngIf ![](https://static.platzi.com/media/user_upload/image-2a53de24-6974-40b1-aef5-11124b80216f.jpg) mi logica me dice que cuando sea 0 se pone el plural
``` \\{{ tasks().length }}\ item{{ tasks().length > 1 ? 's' : '' }} left\ ```
Esta es mi solución ```js {{ tasks().length }} items ```Lo que hago es indicar a Angular que renderice la etiqueta span que contiene la letra "s" en caso de cumplirse la condición de que sea mayor a 1.
Mi solución fue esta sin perder de vista el ngIf y el ng-template: \          \{{ tasks().length }}\          \<ng-container \*ngIf="tasks().length === 1; else elseBlock"> item\</ng-container>          \<ng-template #elseBlock> items\</ng-template>        \
**ng-template** ![](https://static.platzi.com/media/user_upload/ngTemplate-b79a13cf-f50c-46d8-9828-c733a4728196.jpg)
Esta es mi solución: ```js {{tasks().length}} item <ng-template #masItem> items </ng-template> ```
```js {{tasks().length}} item <ng-template #masItem> items </ng-template> ```\        \{{tasks().length}}\        \ item\        \<ng-template #masItem>          \ items\        \</ng-template>      \
Esta es mi solución:\        \{{tasks().length}}\        \ item\        \<ng-template #masItem>          \ items\        \</ng-template>      \ ```html {{tasks().length}} item <ng-template #masItem> items </ng-template> ```
Por si alguien le pasa que a la fecha estamos con la version de angular 19, no viene por default el funcionamiento de \*ngIf solo funciona la version @if que la version actualizada, pero si quieren que funcione la version anterior \*ngIf deberás colocar en tu component.ts la importación del commonModule. Te dejo como quedaría: ![](https://static.platzi.com/media/user_upload/image-2dbbd58e-6cef-4813-829f-7d1cd75cf1f0.jpg)
Mi ejercicio quedo asi: \ {{ tasks().length }} \ item\s\
Comparto mi aporte \{{ tasks().length }}\         @if (tasks().length > 0 && tasks().length === 1) {          item        }@else {          items        }
Así solucioné el reto: \\{{ tasks().length }}\ items\        \<ng-template #elseBlock>\\{{ tasks().length }}\ item\\</ng-template >
Como es solo una palabra utilice el método de condicional ternaria de la siguiente forma: ```js {{tasks().length}} {{tasks().length <= 1 ?'item': 'items'}} ```
Esta seria la forma usando \*ngIf en lo particular se entiende facil pero se me parece muy verboso ```html
{{tasks().length}} items
<ng-template #elseBlock> {{tasks().length}} item </ng-template> ``` Yo prefiero mas esta forma: ```js
{{tasks().length}} item{{tasks().length > 1 ? 's': ''}} ```
Así de fácil ```js
{{tasks().length}} tareas
``` \
{{tasks().length}} tarea\s\ \
Así fue como lo resolví, aplicando lo visto en clase:\ \{{tasks().length}}\ Items \ \<ng-template #elseBlock> \\{{tasks().length}}\ Item\ \</ng-template> ```js {{tasks().length}} Items <ng-template #elseBlock> {{tasks().length}} Item </ng-template> ```
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 `
Para quienes acaban de llegar (septiembre 2024) buscando la nueva forma de lógica, sería así con el @if `        @if (tasks().length === 1) {        {{ tasks().length }} item left        } else {{ tasks().length }} items left      ` Espero les sirva!
mi solucion fue asi para practicar lo visto no pense en modificar la etiqueca span has que vi los otros comentarios. \\{{tasks().length}}\ items\        \<ng-template *#elseblock*> \\{{tasks().length}}\ item\\</ng-template>
Esta fue mi solución: ```js <ng-template [ngIf]="tasks().length !== 1" [ngIfElse]="individualTask"> {{ tasks().length }} items </ng-template> <ng-template #individualTask> {{ tasks().length }} item </ng-template> ```O en imagen ![](https://static.platzi.com/media/user_upload/imagen-9d386676-a79a-448b-9e41-6c147ff1cebc.jpg)
![](https://static.platzi.com/media/user_upload/image-05660a4a-1eba-42ba-9291-a2a6fd5ac018.jpg) Esta fue mi solución, algo rebuscada. Le agregue que si las tareas son 0 , indique que no hay ninguna tarea.![]()
Mi solución aplicando la nueva sintaxis ```js {{countCompletedTasks()}} @if(countCompletedTasks() > 1){ tasks to complete }@else { task to complete } ```\        \{{countCompletedTasks()}}\        @if(countCompletedTasks() > 1){          tasks to complete        }@else {          task to complete        }      \
con las nuevas directivas podria quedar asi: \\{{ tasks().length }}\ item@if (tasks().length>1) {s} left\
Aquí dejo mi aporte a la solución ![](https://static.platzi.com/media/user_upload/image-3bf2b0f9-34f1-4fc7-bdf7-5a6a032d6e3c.jpg)
Compañeros le comparto mi solución ```js {{ tasks().length }}Items <ng-template #itemOne>{{ tasks().length }} Item</ng-template> ```
Mi solución al reto: ```ts {{ tasksSignal().length }} {{tasksSignal().length > 1 ? 'items':'item'}} ```\\{{ tasksSignal().length }}\ {{tasksSignal().length > 1 ? 'items':'item'}}\
![](https://static.platzi.com/media/user_upload/image-ef9d1c35-09ad-4adc-b64d-a0a12f68adac.jpg)
```js {{ tasks().length }} items left ```
```js {{ tasks().length }} items left ```\ \{{ tasks().length }}\ item\s\ left \
![]()![](https://static.platzi.com/media/user_upload/Screen%20Shot%202024-06-13%20at%2006.18.16-42fa48ec-e81f-4156-b2e5-b8bf086005c1.jpg)El uso de ng container permite encapsular elementos html, NO crea u nodo extra en el DOM a diferencia de la etiqueta \
y permite combinar las directivas ngIF y ngFor
**Mi solución** ![](https://static.platzi.com/media/user_upload/image-ddd6a396-b809-46ca-b1b9-f12428c52e73.jpg) Para agregar, también se puede hacer sin el uso de un **\*ngIf** y se vería algo así: {{ tasks().length <= 1 ? "item" : "items" }}
```js {{ tasks().length }} <ng-container *ngIf="tasks().length > 1; else singular"> items </ng-container> <ng-template #singular>item</ng-template> left ``` \ \{{ tasks().length }}\ \<ng-container \*ngIf="tasks().length > 1; else singular"> items \</ng-container> \<ng-template #singular>item\</ng-template> left \
Con los nuevos bloques condicionales de Angular el código queda así: @if (tasks().length > 1) { Items } @else { Item }
Con los nuevos bloques condicionales queda así el código: `@if (tasks().length > 1) { Items } @else { Item }`
mi solucion ![](https://static.platzi.com/media/user_upload/image-1f34a133-7dc0-4083-bb9d-27c12f5a4a50.jpg)![](https://static.platzi.com/media/user_upload/image-5180214b-ddc0-4842-950f-f3171229ff5e.jpg)
Estoy trabajando con la nueva sintaxis de angular 17: `{{tasks().length}}@if (tasks().length>1) { Items } @else { Item } `
Mi solución al reto ````js {{ tasks().length }} items <ng-template #elseBlock> item </ng-template> ``` \                \{{ tasks().length }}\                \ items\                \<ng-template #elseBlock>                    \ item\                \</ng-template>            \ ````
Nota: Normalmente lo que tenemos en un \*ngFor es un array
Una alternativa para ```js age: parseInt(newValue, 10) ```es en la declaración de newValue ```js const newValue = input.valueAsNumber; ```
<span class="todo-count" *ngIf="todos().length > 0">
        <strong>{{ todos().length }}</strong> item left</span
      >
así fue como yo realicé la misión![](https://static.platzi.com/media/user_upload/image-70227969-01c6-4f2f-8862-556a31035efa.jpg)
```js {{toDo().length}} items left <ng-template #item> {{toDo().length}} item left </ng-template> ```
Wenas, aqui mi solución de acuerdo al codigo de la clase. `        {{toDo().length}} items left` `      <ng-template #item>                  {{toDo().length}} item left      </ng-template>`
Mi solución que capaz esta muy larga, pero aqui va!! \\{{ tasks().length}}\ \item\ \items\ \```js {{ tasks().length}} item items ```
```html {{tasks().length}} <ng-container *ngIf="tasks().length <= 1; else elseBlock">item</ng-container> <ng-template #elseBlock>items</ng-template> @if (tasks().length <= 1){item}@else {items} {{tasks().length <= 1?"item":"items"}} left ```
\ \{{*tasks*().length}} \ \<ng-container \*ngIf="*tasks*().length <= 1; else elseBlock">item\</ng-container> \<ng-template #elseBlock>items\</ng-template> *\* @if (*tasks*().length <= 1){item}@else {items} *\* {{*tasks*().length <= 1?"item":"items"}} *\* left \ ```html {{tasks().length}} <ng-container *ngIf="tasks().length <= 1; else elseBlock">item</ng-container> <ng-template #elseBlock>items</ng-template> @if (tasks().length <= 1){item}@else {items} {{tasks().length <= 1?"item":"items"}} left ```

Mi propuesta de solución:

<span class="todo-count">
 <strong>{{ 
	tasks().length }}</strong> item{{ tasks().length > 1 ? "s" : "" 
    }}
</span>
Yo me fui por lo seguro y lo hice tal cual 🫡 \ \{{tasks().length}}\ items  \      \<ng-template #justItem> \ \{{tasks().length}}\          item\ \</ng-template>
\        \{{ tasks().length }}\ items      \      \<ng-template #lessThanOne>        \\{{ tasks().length }}\ item\      \</ng-template>
```js {{tasks().length}} items <ng-template #elseBlock> {{tasks().length}} item </ng-template> ```\\{{tasks().length}}\ items\ \<ng-template #elseBlock> \\{{tasks().length}}\ item\ \</ng-template>
Mi solución: `{{ tasks().length }} item{{tasks().length > 1 ? 's': ''}}`
![]()```html @if (tasks().length > 0) { {{tasks().length}} @if (tasks().length === 1) { item } @else { items } left } ``` Mi solución
con la nueva sintaxis ```js @if(tasks().length > 1) { items } @else { item } left {{ tasks().length }} ```
Mi solución ```js \        \{{tasks().length}} \@if (tasks().length > 1) {items} @else {item} left      \ ```
![]()![](https://static.platzi.com/media/user_upload/code-afc96284-8810-4889-9fa8-9da7cf6b2e05.jpg)
Yo lo resolví de está manera \      \\{{signalTasks().length}}\        item left      \      \<ng-template #moreItems>        \          \{{signalTasks().length}}\ items left        \      \</ng-template>
![]()\ \ {{tasks().length}} \ \<span \*ngIf="tasks().length === 1; else elseBlock" > i tem \ \<ng-template #elseBlock> items \</ng-template>
![](https://static.platzi.com/media/user_upload/image-40909201-28de-4775-b68c-b00fd4cb53cd.jpg)

![](https://static.platzi.com/media/user_upload/image-a5da6dbf-4184-4d22-82f3-1328fb6194fe.jpg)

Esta sería mi solución:
item<ng-container *ngIf=“tasks().length>1”>s</ng-container>

seria bueno que usaras la nueva sintaxis, al estar en la version 17 es bueno ir familiarizandonos con la sintaxis
Esta sería mi solución además añadí un condicional para ocultar todo el elemento si no hay task. ``` \        \{{ tasks().length }}\        {{ tasks().length === 1 ? 'item' : 'items' }}      \ ```
\        \{{tasks().length}} items left\        \<ng-template *#elseBlock*>          {{tasks().length}} item left        \</ng-template>      \

Este sería mi forma haciendo uso también de un bloque else😀

<span *ngIf="tasks().length > 1; else oneElement" class="todo-count"><strong>{{ tasks().length }} </strong> items</span>
        <ng-template #oneElement>
          <span class="todo-count"><strong>{{ tasks().length }} </strong> item</span>
        </ng-template>   

Mi solución:

<span class="todo-count">
	<strong>{{ tasks().length }}</strong> 
	{{ tasks().length == 1 ? 'item' : 'items' }}
</span>
<span class="todo-count"><strong>{{ tasks().length }} </strong>{{ tasks().length === 1 ? 'item' : 'items' }}</span>