Information exchange between various application components is essential, and Angular is not an exception. Angular provides a number of built-in methods to facilitate this prevalent practise. Nonetheless, there may be instances in which these default approaches are insufficient, necessitating the implementation of more creative solutions.

In this session, we will investigate a few of the most common methods for component communication.

The resources I used to create this tutorial are listed below.

1. Visual Studio Code
2. Node 18.14.0
3. Angular 15

• You can transfer data between parent and offspring components using input properties.
• Define an input property in the secondary component using @Input(), and then bind the property in the parent component.
• Employ output properties with events to communicate from the child component to the parent component.
• Define an output property in the child component using @Output() and emit events with EventEmitter.

Let's examine the sample code below, which will give you an overview of parent-to-child and child-to-parent communications.

Parent Component

• Input and Output Properties (Parent-Child Communication)
• You can use input properties to pass data from parent to child components.
• Define an input property in the child component using the @Input() decorator, and then bind the property in the parent component.
• Use output properties with events to communicate from the child component back to the parent component.
• Define an output property in the child component using the @Output() decorator and emit events using EventEmitter.

Let us look at the sample code below, which will give you an overview of parent-to-child and child-to-parent communications.

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

@Component({
  selector: 'app-parent',
  template: `
    <h1>Parent Component</h1>
    <input [(ngModel)]="parentMessage"/>
    <p>{{ childMessage }}</p>
    <app-child [message]="parentMessage" (notify)="onNotify($event)"></app-child>`

})
export class IOParentComponent {
  parentMessage = 'Message from parent';
  childMessage ="";
  onNotify(message: string) {
    this.childMessage =message;
  }
}

Child Component
import { Component, Input, Output, EventEmitter } from '@angular/core';

@Component({
  selector: 'app-child',
  template: `
    <h2>Child Component</h2>
    <p>{{ message }}</p>
    <input [(ngModel)]="childMessage"/>
    <button (click)="notifyParent()">Notify Parent</button>
  `
})
export class IOChildComponent {
  @Input() message: string ='';
  @Output() notify = new EventEmitter<string>();
  childMessage: string ='Message from child';
  notifyParent() {

    this.notify.emit(this.childMessage);
  }
}

Services (Cross-Component Communication) using RxJS Observables and Subjects

• Create a service that can be injected into the components needing to communicate.
• The service acts as a shared source of data and functionality.
• Components can subscribe to data streams or invoke methods provided by the service to communicate with each other.

Let us take a look at the example

Shared Service
import { Injectable } from '@angular/core';
import { Subject } from 'rxjs';

@Injectable()
export class DataService {
  private dataSubject = new Subject<string>();

  setData(data: string) {
    this.dataSubject.next(data);
  }

  getData() {
    return this.dataSubject.asObservable();
  }
}

Component 1
import { Component } from '@angular/core';
import { DataService } from './dataservice.service';

@Component({
  selector: 'app-scomponent1',
  template: `    <h1>Component 1</h1>
    <input type="text" [(ngModel)]="message">
    <button (click)="sendMessage()">Send Message</button>
    <app-component2>/</app-component2>`

})
export class SComponentOne {
  message: string="";

  constructor(private dataService: DataService) { }

  sendMessage() {
    this.dataService.setData(this.message);
  }
}

Component 2
import { Component } from '@angular/core';
import { DataService } from './dataservice.service';

@Component({
  selector: 'app-component2',
  template: `
    <h1>Component 2</h1>
    <p>{{ receivedMessage }}</p>
  `
})
export class SComponentTwo {
  receivedMessage: string ='';

  constructor(private dataService: DataService) { }

  ngOnInit() {
    this.dataService.getData().subscribe(message => {
      this.receivedMessage = message;
    });
  }
}

The below reference link explains the Mediator and Service Bus approaches for component communication in Angular.

Component communication in Angular for Senior devs by 'iamprovidence'

These are some of the commonly used methods for component communication in Angular. The choice of method depends on the specific requirements of your application and the relationship between the components involved.

When it comes to building dynamic Angular applications, handling pluralization is a common requirement. Angular provides a powerful directive called ngPlural that simplifies the process of displaying content based on numeric values. This article will explore the ngPlural directive and learn how to leverage its capabilities effectively.

What is ngPlural?
The ngPlural directive allows us to present different content based on numeric values in our Angular templates. It provides a concise and elegant way to handle pluralization scenarios. By utilizing ngPlural, we can eliminate the need for conditional logic and achieve more maintainable code.

Implementation of ngPlural
To start using ngPlural, we need to import the CommonModule in our Angular module. This ensures that the necessary directives and components are available in our application. Once imported, we can use ngPlural in our templates.
import { CommonModule } from '@angular/common';

@NgModule({
  imports: [
    CommonModule
  ],
  // ...
})
export class AppModule { }

The ngPlural directive works in conjunction with ngPluralCase. Inside the ngPlural element, we define multiple ngPluralCase elements that correspond to specific numeric values or conditions. Angular evaluates the ngPluralCase blocks and renders the appropriate content based on the value provided to ngPlural.

In our template, we can define different cases using the ngPluralCase directive. We specify the value or condition for each case, allowing Angular to determine which content to display. We can have special cases for values like "=0" or "=1", and a generic "other" case that covers all other values.
<div [ngPlural]="numItems">
  <ng-template ngPluralCase="=0">No items</ng-template>
  <ng-template ngPluralCase="=1">One item</ng-template>
  <ng-template ngPluralCase="other">{{ numItems }} items</ng-template>
</div>

Best Practices and Tips

• Be mindful of the data type: Ensure that the variable bound to ngPlural is of a numeric type, as ngPlural evaluates values based on strict equality.
• Consider internationalization: If your application requires localization, use Angular's internationalization (i18n) features in combination with ngPlural to handle pluralization rules specific to different languages.
• Handle complex conditions: ngPlural supports more advanced conditions by allowing you to use expressions within ngPluralCase blocks. This flexibility enables you to handle custom pluralization scenarios efficiently.

A ngPlural directive is a powerful tool for handling pluralization in Angular applications. By using ngPlural and ngPluralCase, we can easily display content based on numeric values, providing a seamless user experience. With the knowledge gained from this article, you're well-equipped to implement ngPlural and enhance your Angular applications with dynamic pluralization capabilities.

Angular v16 introduces a new way to manage state in Angular applications called Signals. Signals are a more lightweight and flexible alternative to Angular's built-in Change Detection mechanism. Signals can be used to track changes to data in your application and trigger the re-rendering of components only when necessary. This can lead to significant performance improvements in large applications.

How to Use Angular Signals?
To use Signals, you first need to import the Signal class from the @angular/core library. Once you have imported the Signal class, you can create a new signal by calling the new Signal() constructor. The new Signal() constructor takes one argument, which is the initial value of the signal.

Once you have created a new signal, you can subscribe to it by calling the subscribe() method. The subscribe() the method takes a callback function as its argument. The callback function will be called whenever the value of the signal changes.

You can also use signals to create computed values. Computed values are derived values that are updated whenever the values of their dependencies change. To create a computed value that depends on a signal, you use the | async pipe.

Example
The following example shows how to use Signals to track changes to a user's name and age.
import { Component, OnInit } from '@angular/core';
import { Signal } from '@angular/core';

@Component({
  selector: 'my-app',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent implements OnInit {

  name = new Signal('');
  age = new Signal(0);

  constructor() {}

  ngOnInit() {
    this.name.subscribe(() => {
      console.log('Name changed to', this.name.value);
    });

    this.age.subscribe(() => {
      console.log('Age changed to', this.age.value);
    });
  }

}

The app.component.html file contains the following code.
<h1>Angular Signals Demo</h1>
<input [(ngModel)]="name" placeholder="Enter your name">
<h2>Age</h2>
<input [(ngModel)]="age" placeholder="Enter your age">

When the user changes the value of the name or age input, the corresponding signal will be updated. The callback function that is subscribed to the signal will then be called. In this case, the callback function will log the new value of the signal to the console.

Angular Signals is a powerful new tool for managing state in Angular applications. Signals can be used to track changes to data in your application and trigger the re-rendering of components only when necessary. This can lead to significant performance improvements in large applications.

We have mostly faced this issue while migrating from AngularJS to a higher version; since the angular higher version does not support ng-init we can use the directive to achieve that,

Init Directive(ng-init.directive.js)
We can generate a directive using the following comment ng g d [directivename], which can declare the selector name which we are going to use in the element as an attribute.

And we going set the output() emitter for the directive, which is going to init for us.
@Directive({
  selector: '[ngInit]'
})
export class NgInitDirective implements OnInit {
  @Output()
    ngInit: EventEmitter<any> = new EventEmitter();

    ngOnInit() {
        this.ngInit.emit();
    }
  }

App.Module.ts for a particular module
Register the custom pipe in the module where you want to use it. For example, open the app.module.ts file and import and add NgInitDirective to the import array:
@NgModule({
  declarations: [....,....],
  imports: [
    NgInitDirective
  ],
  providers: [ ....]

App.Component.html

    In your component's template, pass the desired value, which needs to be initialized as parameters to the (ngInit):

By assigning the value which needs to initialize before rendering the particular <div> or <span>.
<div (ngInit)="AlreadyShown=false">
<div *ngFor="let row of data">
 ....
....
</div>
</div>