Angular components are the foundation of Angular applications, providing a way to build modular, reusable parts of the user interface. In this guide, we’ll cover the basics of Angular components, from their structure to best practices. Whether you’re new to Angular or looking for a refresher, this article will give you a basic understanding of components in Angular.

What is an Angular Component?

In Angular, a component is a class that controls a piece of the user interface (UI). Think about buttons, tabs, inputs, forms and drawers (any bit of UI really). Each component is self-contained, consisting of:

1. HTML Template: Defines the layout and structure of the UI.
2. CSS Styles: Sets the appearance and styles for the component.
3. TypeScript Class: Contains the logic and data for the component.
4. Metadata: Provides configuration details for Angular to recognize and use the component.

Components are essential to creating a modular application, as each one can represent a specific part of a page, such as a header, sidebar, or card.

Basic Structure of an Angular Component

An Angular component is defined using the @Component decorator, which configures it with the necessary template, styles, and selector. Here’s a basic example:

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

@Component({
  selector: 'app-example',
  templateUrl: './example.component.html',
  styleUrls: ['./example.component.css']
})
export class ExampleComponent {
  title: string = 'Hello, Angular!';

  getTitle() {
    return this.title;
  }
}

In this example:

• selector is the HTML tag representing the component.
• templateUrl points to the HTML template file.
• styleUrls refers to the component’s CSS files.
• ExampleComponent class holds the component’s data and logic.

Typical Component Folder Structure

Angular projects generally organize components with their associated files in one folder, created automatically when using the Angular CLI. A typical folder structure for a component includes:

• example.component.ts: Defines the TypeScript class.
• example.component.html: Contains the HTML template.
• example.component.css: Holds the component styles.
• example.component.spec.ts: Contains the tests for the component.

Component Lifecycle

Angular components have a lifecycle with hooks that allow developers to perform actions at various stages. Commonly used lifecycle hooks include:

• ngOnInit: Called after the component is initialized.
• ngOnChanges: Triggered when any data-bound property changes.
• ngOnDestroy: Invoked just before Angular destroys the component.

For example, here’s how ngOnInit is used:

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

@Component({
  selector: 'app-lifecycle',
  template: '<p>Lifecycle example</p>',
})
export class LifecycleComponent implements OnInit {
  ngOnInit() {
    console.log('Component initialized!');
  }
}

Lifecycle hooks provide flexibility, making it easy to manage logic at specific stages of a component's lifecycle.

Communication Between Components

In real-world applications, components often need to interact with each other to share data or trigger actions. Angular provides several methods for component communication:

1. @Input and @Output

• @Input: Allows a parent component to pass data to a child component.
• @Output: Enables a child component to send events to its parent.

Example:

// child.component.ts
import { Component, Input, Output, EventEmitter } from '@angular/core';

@Component({
  selector: 'app-child',
  template: `<button (click)="sendMessage()">Send Message</button>`,
})
export class ChildComponent {
  @Input() childMessage: string;
  @Output() messageEvent = new EventEmitter<string>();

  sendMessage() {
    this.messageEvent.emit('Message from child!');
  }
}

<!-- parent.component.html -->
<app-child [childMessage]="parentMessage" (messageEvent)="receiveMessage($event)"></app-child>

2. Service-Based Communication

When components are not in a parent-child relationship, Angular services offer a straightforward way to share data and logic. Services are singleton by default, meaning only one instance exists across the app.

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

@Injectable({
  providedIn: 'root'
})
export class SharedService {
  private messageSource = new BehaviorSubject<string>('Default Message');
  currentMessage = this.messageSource.asObservable();

  changeMessage(message: string) {
    this.messageSource.next(message);
  }
}

Using the service in different components:

// component-one.ts
import { Component } from '@angular/core';
import { SharedService } from '../shared.service';

@Component({
  selector: 'app-component-one',
  template: `<button (click)="changeMessage()">Change Message</button>`,
})
export class ComponentOne {
  constructor(private sharedService: SharedService) {}

  changeMessage() {
    this.sharedService.changeMessage('Hello from Component One');
  }
}

// component-two.ts
import { Component, OnInit } from '@angular/core';
import { SharedService } from '../shared.service';

@Component({
  selector: 'app-component-two',
  template: `<p>{{ message }}</p>`,
})
export class ComponentTwo implements OnInit {
  message: string;

  constructor(private sharedService: SharedService) {}

  ngOnInit() {
    this.sharedService.currentMessage.subscribe(message => this.message = message);
  }
}

Best Practices for Angular Components

1. Single Responsibility: Ensure each component has one responsibility to improve readability and maintainability.
2. Feature Modules: Organize related components in feature modules, which aids in lazy loading.
3. Optimize Change Detection: Use OnPush change detection for components that don’t update frequently to improve performance.
4. Limit Service Use for Communication: While services are valuable for sharing data, over-reliance on them can lead to tightly coupled code. Use @Input and @Output for parent-child communication whenever possible.
5. Simplify Templates: Keep templates as simple as possible, moving complex logic into the component class.

Conclusion

Angular components are at the core of building scalable and modular applications. By understanding their structure, lifecycle, and communication methods, you can create efficient, maintainable applications that are easy to understand and build upon.

In the next article, we’ll dive into the Angular component lifecycle in more detail, exploring each hook and how it can be used to manage components effectively. Stay tuned for a deeper look into Angular's powerful lifecycle features!