Nico Jonsson

Nico Jonsson


Effective Component Patterns in Angular

I have built a sample Angular application displaying four component patterns. These patterns are simple yet effective for sharing data between components. We will use concrete examples of these patterns to illustrate how to use them.

Download the source code on Github 🚀

We will cover:

  • Passing data from a parent component to a child component
  • Passing data between sibling components
  • Passing data from one component to an unrelated component.
  • Multidirectional data passing between a parent and children components

Parent to Child Pattern

We can implement various patterns based on where our components are in relation to each other in the DOM. Whenever we need to facilitate communication between two components, we can reach for one of these patterns based on their relationship.

A parent-child relationship exists when an element (child) lives inside another element (parent)*. Our parent to child example will be a “Terms of Service” checkbox that will display a tool-tip on hover. When the box is checked, the message for the tool-tip will change.

This is image title

Subject and Observable — Maintaining and Emitting State Changes

All of our patterns will utilize a BehaviorSubject/state and an Observable/eventStream$ created from the BehaviorSubject. This allows us to maintain state in the BehaviorSubject and emit changes to that state through the Observable.

Tip: Utilizing a private BehaviorSubject and a public Observable allows us to lock down access to our state and prevent excessive modification.

export class ParentComponent implements OnInit {
  private state = new BehaviorSubject({
    enabled: false,
    toolTip: false
  public eventStream$ = this.state.asObservable()

  update(value, command) {
    let update = this.state.value;
    if (command === 'enabled') update.enabled = value;
    if (command === 'toolTip') update.toolTip = value;;

Now we can leverage Angular Event Binding with RxJS to trigger updates to our state/data. Whenever the parent’s input is changed or interacts with the mouse, the parent state will be updated.

All of our patterns will leverage Angular Event Binding and RxJS similar to this. The key differences will be how the components receive Observables, or how they pass state changes to each other.

<span>Agree to the Terms of Service:</span> 
<input #toggle type="checkbox" 
(change)="update(toggle.checked, 'enabled')" 
(mouseover)="update(true, 'toolTip')"
(mouseleave)="update(false, 'toolTip')">
<app-child [eventStream]="eventStream$"></app-child>

@Input — Receiving Changes in the Child Component

On initialization, our parent will pass its Observable to our child using @Input. Once the input has been initialized, the child will receive any changes to the parent state through our async pipe subscription. [3]

Utilizing this pattern, our components are now completely reactive. This simplifies working with the components when debugging or making future modifications.

<ng-container *ngIf="eventStream$ | async as toggle">
  <div *ngIf="toggle.toolTip">{{getMessage(toggle.enabled)}}</div>

Alternative Use of Observable and @Input

Instead of passing the entire Observable, we can use an async pipe to unwrap and pass the value from the parent to the child. Use-based on preference or if one suits a particular need better than the other.**

<ng-container *ngIf="eventStream$ | async as eventData">
  <span>Agree to the Terms of Service:</span> 
<input #toggle type="checkbox" 
(change)="update(toggle.checked, 'enabled')" 
(mouseover)="update(true, 'toolTip')"
(mouseleave)="update(false, 'toolTip')">
  <app-child [eventData]="eventData"></app-child>
<div *ngIf="eventData.toolTip">

Siblings Pattern

A sibling-relationship exists when multiple elements share a common parent element. Our sibling components example will be a color-picker that alters the color of a display. In this example, only our color-picker will update state. However, utilizing this pattern, any number of siblings could update state.

This is image title

Container and Directive — Facilitating Communication

To pass data between our sibling components; we will wrap them in a container, such as div or ng-container, and apply an Angular Directive to the container. This Directive will act as a parent or intermediary between the siblings for passing state/data to and from each other.

Similar to our parent-child pattern, we still utilize a private BehaviorSubject. However, we will expose our method for updating state to the siblings. This allows the siblings to send new data to our BehaviorSubject without directly accessing it.

export class ParentDirective {
  private state = new BehaviorSubject('#1e90ff');
  public eventStream$ = this.state.asObservable();

  updateColor(color) {;

Injecting the Directive — Accessing State

Our sibling components inject the parent directive. This gives them the ability to reference our Directive’s Observable color$. To access the value emitted from color$ we will utilize the async pipe. Ideally, we want to use an async pipe whenever applicable.

<ng-container *ngIf="color$ | async as color">
  <input #picker type="color" 

// Typescript
export class ChildTwoComponent implements OnInit {


  constructor(public directive: ParentDirective) { }

  ngOnInit() {
    this.color$ = this.directive.eventStream$;

  updateColor(val) {

We can add as many siblings as we want. We simply have to add the sibling element to the container and it will be able to send and receive data from the other components.

<div appParent>

Unrelated Pattern

Elements that do not share a mutual parent are considered unrelated. Our example will be a button and a toast message that do not share a common parent or wrapper. We will utilize an Angular Service to facilitate data sharing between the two components.

This is image title

Injecting the Service — Accessing State

This pattern is similar to the sibling pattern. The key difference is that we utilize an Angular Service instead of an Angular Directive. The advantage of the Service is that we no longer need both components in the same container.

Compared to a Directive, a potential disadvantage of a Service is the increased complexity if we need multiple instances of the Service. In this scenario, we only need a single instance of the Service.

export class ToastService {

  private bs = new BehaviorSubject(false);
  public eventStream$ =;

  constructor() {}

  public setEnabled() {
    if (! {;
      setTimeout(val => {;
      }, 5000);

Whenever the ActivatorComponent makes an update to the ToastService the ToastComponent will receive the update through the Service. An @Input is not needed in the scenario, as everything is facilitated through the Service.

export class ActivatorComponent {

  constructor(private ts: ToastService) { }

  onChange() {

export class ToastComponent {


  constructor(private ts: ToastService) {
    this.eventStream$ = ts.eventStream$;

Multidirectional Data

Our last pattern will feature a parent element with multiple children elements. The parent will be able to pass state/data down to the children and the children will be able to pass state/data back up to the parent.

This is image title

Subject and Observable — Maintaining and Emitting State Changes

Similar to the parent-child pattern we will utilize a private BehaviorSubject and a public Observable to maintain state and emit changes to the children.

export class MultiParentComponent implements OnInit {
  private state = new BehaviorSubject('Off');
  public eventStream$: Observable<any> = this.state.asObservable();

  updateStatus(value) {
    // ...'Process Complete');
    // ...

@Output — Receiving Changes in the Parent Component

This is the key difference that makes our pattern multi-directional.

**We utilize an @Output to allow our children components to emit events/state up to our parent component.

We will replace our Observable in this scenario with an EventEmitter. Using EventEmitter with @Output is common practice and supported by the documentation.

<!-- Parent HTML -->
<button #startBtn type="button" (click)="'Running')">Start</button>
<app-multi-child [eventStream]="eventStream$" (done)="updateStatus($event)"></app-multi-child>
<app-multi-child [eventStream]="eventStream$" (done)="updateStatus($event)"></app-multi-child>

<!-- app-multi-child HTML -->
<div *ngIf="eventStream$ | async as status">
  <span *ngIf="state.value as value">{{value}}</span>  

When our EventEmitter emits a value, the done($event) method will be called. $event will contain whatever state/data that was emitted from our EventEmitter.

To maintain state and use the value in both the child and the parent, we emit the events on changes to our BehaviorSubject. If we did not need to maintain state, we could omit the BehaviorSubject and use just the EventEmitter.**

@Input('eventStream') eventStream$;

state: BehaviorSubject<string> = new BehaviorSubject('');
@Output('done') eventEmitter = new EventEmitter<string>();
// outputStream$ = this.state.asObservable();
ngOnInit() {
  this.state.subscribe(tap(val => {
  })); // Unsubscribe in ngOnDestroy  
 // ...


  • Parent to Child Pattern: Utilize a Subject and Observable in the parent and an @Input in the child to facilitate sending data from the parent to the child
  • Siblings Pattern: Subject and Observable live inside a Directive that acts as an intermediary for sending and receiving data between siblings
  • Unrelated Pattern: Subject and Observable live inside a Service, components do not have to share a parent or container
  • Multidirectional Parent Child Pattern: Same as the Parent to Child pattern. Adds an @Output to the children components to send state/events back to the parent.

Thanks for reading! If you enjoyed this article, please share it with others who may enjoy it as well.!

Originally published on

#angular #javascript #web-development

What is GEEK

Buddha Community

Effective Component Patterns in Angular
Christa  Stehr

Christa Stehr


Install Angular - Angular Environment Setup Process

Angular is a TypeScript based framework that works in synchronization with HTML, CSS, and JavaScript. To work with angular, domain knowledge of these 3 is required.

  1. Installing Node.js and npm
  2. Installing Angular CLI
  3. Creating workspace
  4. Deploying your First App

In this article, you will get to know about the Angular Environment setup process. After reading this article, you will be able to install, setup, create, and launch your own application in Angular. So let’s start!!!

Angular environment setup

Install Angular in Easy Steps

For Installing Angular on your Machine, there are 2 prerequisites:

  • Node.js
  • npm Package Manager

First you need to have Node.js installed as Angular require current, active LTS or maintenance LTS version of Node.js

Download and Install Node.js version suitable for your machine’s operating system.

Npm Package Manager

Angular, Angular CLI and Angular applications are dependent on npm packages. By installing Node.js, you have automatically installed the npm Package manager which will be the base for installing angular in your system. To check the presence of npm client and Angular version check of npm client, run this command:

  1. npm -v

Installing Angular CLI

  • Open Terminal/Command Prompt
  • To install Angular CLI, run the below command:
  1. npm install -g @angular/cli

installing angular CLI

· After executing the command, Angular CLI will get installed within some time. You can check it using the following command

  1. ng --version

Workspace Creation

Now as your Angular CLI is installed, you need to create a workspace to work upon your application. Methods for it are:

  • Using CLI
  • Using Visual Studio Code
1. Using CLI

To create a workspace:

  • Navigate to the desired directory where you want to create your workspace using cd command in the Terminal/Command prompt
  • Then in the directory write this command on your terminal and provide the name of the app which you want to create. In my case I have mentioned DataFlair:
  1. Ng new YourAppName

create angular workspace

  • After running this command, it will prompt you to select from various options about the CSS and other functionalities.

angular CSS options

  • To leave everything to default, simply press the Enter or the Return key.

angular setup

#angular tutorials #angular cli install #angular environment setup #angular version check #download angular #install angular #install angular cli

Roberta  Ward

Roberta Ward


Basics of Angular: Part-1

What is Angular? What it does? How we implement it in a project? So, here are some basics of angular to let you learn more about angular.

Angular is a Typescript-based open-source front-end web application platform. The Angular Team at Google and a community of individuals and corporations lead it. Angular lets you extend HTML’s syntax to express your apps’ components clearly. The angular resolves challenges while developing a single page and cross-platform applications. So, here the meaning of the single-page applications in angular is that the index.html file serves the app. And, the index.html file links other files to it.

We build angular applications with basic concepts which are NgModules. It provides a compilation context for components. At the beginning of an angular project, the command-line interface provides a built-in component which is the root component. But, NgModule can add a number of additional components. These can be created through a template or loaded from a router. This is what a compilation context about.

What is a Component in Angular?

Components are key features in Angular. It controls a patch of the screen called a view. A couple of components that we create on our own helps to build a whole application. In the end, the root component or the app component holds our entire application. The component has its business logic that it does to support the view inside the class. The class interacts with the view through an API of properties and methods. All the components added by us in the application are not linked to the index.html. But, they link to the app.component.html through the selectors. A component can be a component and not only a typescript class by adding a decorator @Component. Then, for further access, a class can import it. The decorator contains some metadata like selector, template, and style. Here’s an example of how a component decorator looks like:

    selector: 'app-root',
    templateUrl: 'app.component.html',
    styleUrls: ['app.component.scss']

Role of App Module

Modules are the package of functionalities of our app. It gives Angular the information about which features does my app has and what feature it uses. It is an empty Typescript class, but we transform it by adding a decorator @NgModule. So, we have four properties that we set up on the object pass to @NgModule. The four properties are declarations, imports, providers, and bootstrap. All the built-in new components add up to the declarations array in @NgModule.

declarations: [
imports: [
bootstrap: [AppComponent]

What is Data Binding?

Data Binding is the communication between the Typescript code of the component and the template. So, we have different kinds of data binding given below:

  • When there is a requirement to output data from our Typescript code in the HTML template. String interpolation handles this purpose like {{data}} in HTML file. Property Binding is also used for this purpose like [property] = “data”.
  • When we want to trigger any event like clicking a button. Event Binding works while we react to user events like (event) = “expression”.
  • When we can react to user events and output something at the same time. Two-way Binding is used like [(ngModel)] = “data”.

image for understanding data binding

#angular #javascript #tech blogs #user interface (ui) #angular #angular fundamentals #angular tutorial #basics of angular

Christa  Stehr

Christa Stehr


Angular Architecture Components and Features

Angular is one of the most popular frameworks for developing Desktop and mobile applications for clients. Angular application uses HTML and TypeScript. You can use this in cross-platform mobile development via IONIC. Angular Implements both Core and Optional functionalities in the form of TypeScript libraries that you can import in your application. You should have domain knowledge of HTML, CSS, and JavaScript for working with Angular. In this Angular Tutorial by DataFlair, we will learn about Angular Architecture and its components.

There are three basic things in Angular that are Components, Modules, and Routing. An angular app is a combination of different NgModules as modules are the building block of angular. Components, on the other hand, are responsible for defining the views, which are a part of elements of the screen. You can change the Views using data and program logic. Routing is the functionality that links multiple components together.

angular architecture

Architecture of Angular

The Building blocks of Angular Architecture as depicted in the image are:

Architecture of angular

  • Module
  • Template
  • Component
  • Metadata
  • Data Binding
  • Services
  • Directives
  • Dependency Injection

Let us learn each of these Angular Architecture Components in detail now:

1. Module

Angular is a modular platform and it may contain one or more Angular Module or NgModules depending on the demand. It is the essential module that is always present is the Root module namely “AppModule” in the application.

Flow of angular application

NgModule is a Decorator function that handles the compilation part of the application. It works in synergy with other modules. It takes a single object in the form of Metadata. NgModule communicates with other modules for bootstrapping them and works in the Parent-Child relationship for the proper execution of the application.

Here are the properties of NgModule:

Angular NgModule Elaborated

#angular tutorials #angular architecture #angular architecture components #angular architecture working

Marcelle  Smith

Marcelle Smith


Angular Revisited: Tree-shakable Components And Optional NgModules

NgModule is arguably one of the most confusing Angular concepts.

Fortunately, Angular is moving towards a future in which we need Angular modules (NgModules) less often or not at all.

In a future version of Angular, Ivy will enable us to bootstrap or render components to the DOM without any Angular modules. We will also be able to use other components, directives, and pipes in our component templates without Angular modules to resolve them.

These features are not yet available, but we can start preparing now to ease the migration path.

#angular #components #design-patterns #software-architecture #angular-ivy

Dvir Shabi


Angular Components and Their Types

In Angular, components play a very important role. The whole structure of the application is built using different components. Components help in maintaining the modularity of the application as they are reusable. Components control the view, i.e. components are the classes that interact with the HTML file and ultimately resulting in controlling what is displayed in the browser. In this article, you will get to know about all the various components present in the angular application by default and how you can add or remove components.

#angular tutorials #angular components #angular