In our previous article, we tackled the foundations of how to create an Angular project. This time, we will explore Angular components. This feature allows you to build modular UI elements, making it easier to maintain and develop your application. In this blog post, we will learn what Angular components are, and the important pieces that make up these components, the Template, class, and Metadata.

What is an Angular Component?

Angular components are the fundamental building blocks of Angular applications. They hold the view and control the logic behind that view. Every Angular application has at least one component, called the root component, which connects to the Angular application bootstrapper. Components are defined using the @Component decorator, which is part of the Angular Core library.

Class of the Component

The Class in an Angular Component acts as the backbone of the component, housing the logic for the component. It is where you define methods, handle data, and bind it to the template. Essentially, it controls the behavior of the view. This class is an exportable TypeScript class, decorated with @Component to classify it as a component. In this class, you may define properties (data) and methods (logic) that can be bound to the view, allowing for interactivity and dynamic content in your Angular application. Inside this class, we can also have some life cycle hooks that can define the changes in the life of this component.

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


selector: 'app-example',

template: ``


export class ExampleComponent {


So in this code snippet, it’s clear we already needed the @Component decorator and specified our component name ExampleComponent.

Template (view)

One important piece that makes up an Angular component is the Template class. This holds the HTML content and defines the component’s view The HTML content is constructed using directives, which effectively represent a concept in your Angular application. Directives tell Angular how to alter the HTML rendering, dynamic data binding, and allow it to interact with the component’s controller.

Here’s a basic example of a template in an Angular component:

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


selector: 'app-example',

template: `

<h1>Hello, {{name}}!</h1>

<button (click)="changeName()">Change Name</button>



export class ExampleComponent {

name: string = 'Angular';

changeName() { = 'World';



In the code snippet above, the `template` field within the `@Component` decorator holds the HTML content of the component. It uses interpolation (`{{name}}`) for dynamic data binding and event binding (`(click)=”changeName()”`) to interact with the component’s controller.

Component Metadata

The other important piece that composes an Angular component is Metadata.

Component’s Selector

The selector property in the @Component decorator is a CSS selector that Angular uses to create an instance of the component in the host HTML. It essentially gives the component an HTML tag. For example:

selector: 'app-example'

Template URL

The `templateUrl` property is where the HTML template of the component is located and loaded from. For instance:

templateUrl: './app.component.html'

Style URLs

The `styleUrls` property is an array where the paths to the CSS file are located. These styles will be applied to the component’s template. Example:

styleUrls: ['./app.component.css']


The `providers` property is another important field in the `@Component` decorator, which is used to register the services that this component requires. By registering a provider, we tell Angular to create a new instance of the service when a component requests it. Here’s how it’s typically used:

providers: [ExampleService]

How to create an Angular component?

Create a Component with Angular CLI

The Angular CLI (Command Line Interface) is a powerful tool that simplifies the process of creating and managing Angular applications. To generate a new component, use the `ng generate component` command in the terminal. If, for example, you want to create a component named ‘test’, you would type `ng generate component test` or `ng g c test` for short. This command instructs Angular CLI to create a new folder named ‘test’ in the ‘app’ directory. Inside this folder, four files will be automatically created: `test.component.css` (for styles), `test.component.html` (the template), `test.component.spec.ts` (for testing), and `test.component.ts` (the component class). The new component ‘test’ will be automatically declared in the `app.module.ts` file.

Create a Component Manually

Creating an Angular component is also simple manually, You just have to type this command. First,

create a new file for your component and import the necessary libraries.

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


selector: 'app-example',

templateUrl: './example.component.html',

styleUrls: ['./example.component.css']


Next, define the component using the @Component decorator. Give your component a unique selector, define the template URL, and add any necessary styling. Once you have defined your component, your HTML content can be found in the template file.

export class ExampleComponent implements OnInit {

constructor() { }

ngOnInit(): void {



Finally, add the new component to your app.module.ts file. First, import the component file and declare it in the declarations array.

import { ExampleComponent } from './example/example.component';


declarations: [




imports: [




providers: [],

bootstrap: [AppComponent]



Angular components are the building blocks of Angular applications. Components are composed of a Template class, which defines the HTML content for the component, and Metadata, which defines how the component should be processed. Creating a new component is as simple as importing the necessary libraries, defining the component with the @Component decorator, and then adding the component to the app.module.ts file. By using components, you can build more maintainable and modular Angular applications. go here for more content.