En esta sección, exploraremos la arquitectura de Angular, un framework de desarrollo de aplicaciones web robusto y escalable. Comprender la arquitectura de Angular es fundamental para desarrollar aplicaciones eficientes y bien estructuradas. A lo largo de esta lección, cubriremos los siguientes temas:

  1. Componentes
  2. Módulos
  3. Servicios
  4. Directivas
  5. Pipes
  6. Inyección de Dependencias
  7. Enrutamiento

  1. Componentes

¿Qué es un Componente?

Un componente es una de las piezas fundamentales de Angular. Cada componente en Angular consta de:

  • Clase: Define la lógica y los datos del componente.
  • Plantilla: Define la vista del componente, es decir, el HTML.
  • Estilos: Define los estilos CSS específicos del componente.

Ejemplo de un Componente

import { Component } from '@angular/core';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
  title = 'mi-primera-app';
}

En este ejemplo, AppComponent es un componente básico con un selector app-root, una plantilla app.component.html y estilos app.component.css.

  1. Módulos

¿Qué es un Módulo?

Un módulo en Angular es un contenedor que agrupa componentes, directivas, pipes y servicios relacionados. Cada aplicación Angular tiene al menos un módulo, el módulo raíz, que se llama AppModule.

Ejemplo de un Módulo

import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { AppComponent } from './app.component';

@NgModule({
  declarations: [
    AppComponent
  ],
  imports: [
    BrowserModule
  ],
  providers: [],
  bootstrap: [AppComponent]
})
export class AppModule { }

En este ejemplo, AppModule es el módulo raíz que declara AppComponent y lo arranca.

  1. Servicios

¿Qué es un Servicio?

Un servicio en Angular es una clase que contiene lógica de negocio y puede ser inyectada en componentes y otros servicios. Los servicios son ideales para compartir datos y funcionalidades entre diferentes partes de la aplicación.

Ejemplo de un Servicio

import { Injectable } from '@angular/core';

@Injectable({
  providedIn: 'root'
})
export class DataService {
  getData() {
    return ['dato1', 'dato2', 'dato3'];
  }
}

En este ejemplo, DataService es un servicio que proporciona un método getData para obtener datos.

  1. Directivas

¿Qué es una Directiva?

Las directivas son instrucciones en el DOM que Angular interpreta y transforma. Hay tres tipos de directivas:

  • Directivas de Atributo: Modifican el comportamiento de un elemento, atributo o componente existente.
  • Directivas Estructurales: Cambian la estructura del DOM, añadiendo o eliminando elementos.
  • Componentes: Son directivas con una plantilla asociada.

Ejemplo de una Directiva Estructural

<div *ngIf="isVisible">Este texto es visible</div>

En este ejemplo, *ngIf es una directiva estructural que muestra o oculta el div basado en la condición isVisible.

  1. Pipes

¿Qué es un Pipe?

Los pipes son funciones que transforman los datos en plantillas. Angular proporciona varios pipes incorporados, como DatePipe, UpperCasePipe, LowerCasePipe, etc.

Ejemplo de un Pipe

<p>{{ today | date:'fullDate' }}</p>

En este ejemplo, el pipe date transforma la fecha today en un formato de fecha completo.

  1. Inyección de Dependencias

¿Qué es la Inyección de Dependencias?

La inyección de dependencias (DI) es un patrón de diseño en el que una clase solicita dependencias de fuentes externas en lugar de crearlas. Angular utiliza un inyector para proporcionar las dependencias necesarias a los componentes y servicios.

Ejemplo de Inyección de Dependencias

import { Component, OnInit } from '@angular/core';
import { DataService } from './data.service';

@Component({
  selector: 'app-data',
  templateUrl: './data.component.html'
})
export class DataComponent implements OnInit {
  data: string[];

  constructor(private dataService: DataService) {}

  ngOnInit() {
    this.data = this.dataService.getData();
  }
}

En este ejemplo, DataService se inyecta en DataComponent a través del constructor.

  1. Enrutamiento

¿Qué es el Enrutamiento?

El enrutamiento en Angular permite navegar entre diferentes vistas o componentes dentro de una aplicación. Angular Router es el módulo que gestiona el enrutamiento.

Ejemplo de Configuración de Rutas

import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { HomeComponent } from './home/home.component';
import { AboutComponent } from './about/about.component';

const routes: Routes = [
  { path: '', component: HomeComponent },
  { path: 'about', component: AboutComponent }
];

@NgModule({
  imports: [RouterModule.forRoot(routes)],
  exports: [RouterModule]
})
export class AppRoutingModule { }

En este ejemplo, se configuran dos rutas: una para HomeComponent y otra para AboutComponent.

Conclusión

En esta lección, hemos cubierto los componentes clave de la arquitectura de Angular, incluyendo componentes, módulos, servicios, directivas, pipes, inyección de dependencias y enrutamiento. Estos elementos trabajan juntos para crear aplicaciones web robustas y escalables. En las próximas lecciones, profundizaremos en cada uno de estos conceptos para que puedas aplicarlos de manera efectiva en tus proyectos Angular.

Curso de Angular 2+

Módulo 1: Introducción a Angular

Módulo 2: Conceptos Básicos de TypeScript

Módulo 3: Componentes y Plantillas

Módulo 4: Directivas y Pipes

Módulo 5: Servicios e Inyección de Dependencias

Módulo 6: Enrutamiento y Navegación

Módulo 7: Formularios en Angular

Módulo 8: Cliente HTTP y Observables

Módulo 9: Gestión de Estado

Módulo 10: Pruebas en Angular

Módulo 11: Temas Avanzados

Módulo 12: Despliegue y Mejores Prácticas

© Copyright 2024. Todos los derechos reservados