How to use form builders in Angular 8 to validate reactive forms
Tags: angular, javascript, tutorial
Published: 2019-09-06 13:35:22

---
title: How to use form builders in Angular 8 to validate reactive forms
published: true
tags: angular, javascript, tutorial
canonical_url: https://blog.logrocket.com/form-builders-angular-8-validate-reactive-forms/
cover_image: https://thepracticaldev.s3.amazonaws.com/i/3w78s6zly4bbmdajog3l.jpeg
---
**Written by [Nwose Lotanna](https://blog.logrocket.com/author/nwoselotanna/)**✏️

Previously, we discussed [how to manage reactive form controls](https://dev.to/bnevilleoneill/how-to-manage-reactive-form-controls-with-form-groups-in-angular-8-1mn4) with form groups in Angular 8. This is a new post on building reactive forms in Angular 8. Here’s a brief recap of the concepts we discussed in the last post.

## Forms controls and form groups in Angular

Form controls are basically classes that can hold both the data values and the validation information of any form element, which means to say every form input you have in a reactive form should be bound by a form control. They are the basic units that make up reactive forms.

Form groups are constructs that basically wrap a collection of form controls. Just as the control gives you access to the state of an element, the group gives the same access, but to the state of the wrapped controls. Every single form control in the form group is identified by name when initializing.

## Generating form controls

Setting up form controls, especially for very long forms, can quickly become both monotonous and stressful. Angular provides a helper service to solve this problem so that you can always obey the DRY concept of avoiding repetition. This service is called the form builder service.

[![LogRocket Free Trial Banner](https://i0.wp.com/blog.logrocket.com/wp-content/uploads/2017/03/f760c-1gpjapknnuyhu8esa3z0jga.png?resize=1200%2C280&ssl=1)](https://logrocket.com/signup/)

## Before we start…

To be able to follow through this article’s demonstration, you should have:

- Node version 11.0 installed on your machine
- Node Package Manager version 6.7 (usually ships with the Node installation)
- [Angular CLI](https://cli.angular.io/) version 8.0
- The latest version of Angular (version 8)
```jsx
// run the command in a terminal
ng version
```
Confirm that you are using version 8, and update to 8 if you are not.

- Download this tutorial’s starter project [here](https://github.com/viclotana/ng-group) to follow through the demonstrations.
- Unzip the project and initialize the Node modules in your terminal with this command:
```jsx
npm install
```
Other things that would be nice to have are:

- A working knowledge of the Angular framework at a beginner level
- Familiarity with form controls in Angular will be a plus but not a requirement

## Demo

In this tutorial, you will be taken through a code-along journey building a reactive form with the form builder. If you have followed this post from the start, you will have downloaded and opened [the starter project](https://github.com/viclotana/ng-group) in VS Code. If you open the `employee.component.ts`, file it should look like this:

```jsx
import { Component, OnInit } from '@angular/core';
import { FormControl, FormGroup } from '@angular/forms'
@Component({
  selector: 'app-employee',
  templateUrl: './employee.component.html',
  styleUrls: ['./employee.component.css']
})
export class EmployeeComponent implements OnInit {
  bioSection = new FormGroup({
    firstName: new FormControl(''),
    lastName: new FormControl(''),
    age: new FormControl(''),
    stackDetails: new FormGroup({
      stack: new FormControl(''),
      experience: new FormControl('')
    }),
    address: new FormGroup({
        country: new FormControl(''),
        city: new FormControl('')
    })
  });
constructor() { }
ngOnInit() {
  }
  callingFunction() {
    console.log(this.bioSection.value);
   }
}
```

You can see that every single form control — and even the form group that partitions it — is spelled out, so over time, you as the developer keep repeating yourself. The form builder helps to solve this efficiency problem. To use the form builder, you must first register it.

### Registering the form builder

To register the form builder in a component, the first thing to do is import it from Angular forms:

```jsx
import { FormBuilder } from ‘@angular/forms’;
```

The next step is to inject the form builder service, which is an injectable provider that comes with the reactive forms module. You can then use the form builder after injecting it. Navigate to the `employee.component.ts` file and copy in the code block below:

```jsx
import { Component, OnInit } from '@angular/core';
import { FormBuilder } from '@angular/forms'
@Component({
  selector: 'app-employee',
  templateUrl: './employee.component.html',
  styleUrls: ['./employee.component.css']
})
export class EmployeeComponent implements OnInit {
  bioSection = this.fb.group({
    firstName: [''],
    lastName: [''],
    age: [''],
    stackDetails: this.fb.group({
      stack: [''],
      experience: ['']
    }),
    address: this.fb.group({
        country: [''],
        city: ['']
    })
  });
constructor(private fb: FormBuilder) { }
ngOnInit() {
  }
  callingFunction() {
    console.log(this.bioSection.value);
   }
}
```

This does exactly the same thing as the previous code block you saw at the start, but you can see there is a lot less code and more structure — and, thus, optimal usage of resources. Form builders not only help to make your reactive forms’ code efficient, but they are also important for form validation.

### Form validation

Using reactive forms in Angular, you can validate your forms inside the form builders. Run your application in development with the command:

```jsx
ng serve
```

You will discover that the form submits even when you do not input values into the text boxes. This can easily be checked with form validators in reactive forms. The first thing to do, as with all elements of reactive forms, is to import it from Angular forms.

```jsx
import { Validators } from '@angular/forms';
```

You can now play around with the validators by specifying the form controls that must be filled in order for the submit button to be active. Copy the code block below into the `employee.component.ts` file:

The last thing to do is to make sure the submit button’s active settings are set accordingly. Navigate to the `employee.component.html` file and make sure the submit statement looks like this:

```jsx
<button type=”submit” [disabled]=”!bioSection.valid”>Submit Application</button>
```

If you run your application now, you will see that if you do not set an input for first name, you cannot submit the form — isn’t that cool? There are many more cool form validation tips you can get from [the official guide here](https://angular.io/guide/form-validation).

### Displaying input values and status

The last thing you should know is how to use the value and status properties to display, in real time, the input values of your reactive form and whether it can be submitted or not.

The reactive forms API lets you use the value and status properties on your form group or form controls in the template section. Open your `employee.component.html` file and copy in the code block below:

```jsx
<form [formGroup]="bioSection" (ngSubmit)="callingFunction()">
    <h3>Bio Details
</h3>

  <label>
    First Name:
    <input type="text" formControlName="firstName">
  </label> <br>
<label>
    Last Name:
    <input type="text" formControlName="lastName">
  </label> <br>
<label>
    Age:
    <input type="text" formControlName="age">
  </label>
<div formGroupName="stackDetails">
    <h3>Stack Details</h3>

    <label>
      Stack:
      <input type="text" formControlName="stack">
    </label> <br>

    <label>
      Experience:
      <input type="text" formControlName="experience">
    </label>
  </div>
<div formGroupName="address">
    <h3>Address</h3>

    <label>
      Country:
      <input type="text" formControlName="country">
    </label> <br>

    <label>
      City:
      <input type="text" formControlName="city">
    </label>
  </div>
<button type="submit" [disabled]="!bioSection.valid">Submit Application</button>
  <p>
    Real-time data: {{ bioSection.value | json }}
  </p>
  <p>
    Your form status is : {{ bioSection.status }}
  </p>
</form>
```

This displays both the value and the status for submission for you in the interface as you use the form. The complete code to this tutorial can be found here on GitHub.

## Conclusion

This article gives an overview of the form builder and how it is a great efficiency enabler for form controls and form groups. It also shows how important it can be for handling form validation easily with reactive forms. Happy hacking!
* * *
**Editor's note:** Seeing something wrong with this post? You can find the correct version [here](https://blog.logrocket.com/form-builders-angular-8-validate-reactive-forms/).

## Plug: [LogRocket](https://logrocket.com/signup/), a DVR for web apps
 
![LogRocket Dashboard Free Trial Banner](https://i2.wp.com/blog.logrocket.com/wp-content/uploads/2017/03/1d0cd-1s_rmyo6nbrasp-xtvbaxfg.png?resize=1200%2C677&ssl=1)
 
[LogRocket](https://logrocket.com/signup/) is a frontend logging tool that lets you replay problems as if they happened in your own browser. Instead of guessing why errors happen, or asking users for screenshots and log dumps, LogRocket lets you replay the session to quickly understand what went wrong. It works perfectly with any app, regardless of framework, and has plugins to log additional context from Redux, Vuex, and @ngrx/store.
 
In addition to logging Redux actions and state, LogRocket records console logs, JavaScript errors, stacktraces, network requests/responses with headers + bodies, browser metadata, and custom logs. It also instruments the DOM to record the HTML and CSS on the page, recreating pixel-perfect videos of even the most complex single-page apps.
 
[Try it for free](https://logrocket.com/signup/).
* * *
The post [How to use form builders in Angular 8 to validate reactive forms](https://blog.logrocket.com/form-builders-angular-8-validate-reactive-forms/) appeared first on [LogRocket Blog](https://blog.logrocket.com).