Why reactive forms are preferred in Angular - See It in Action

Building a Reactive Form in Angular

📖 Scenario: You are creating a simple user registration form for a website. You want to use Angular's reactive forms to handle the form inputs and validations efficiently.

🎯 Goal: Build a reactive form in Angular with fields for username and email. Add a configuration for validation rules and implement the core logic to create the form controls. Finally, complete the form setup to make it ready for use in the template.

📋 What You'll Learn

Create a FormGroup with controls for username and email

Add validation rules for required fields

Use reactive form patterns with FormBuilder

Complete the form setup for template binding

💡 Why This Matters

🌍 Real World

Reactive forms are used in real-world Angular applications to build complex forms with dynamic validation and better control over form data.

💼 Career

Understanding reactive forms is essential for Angular developers as it is a common pattern in professional web development for handling user input efficiently and cleanly.

1

Set up the form data structure

Import FormBuilder and FormGroup from @angular/forms and create a variable called registrationForm of type FormGroup.

Angular

import { FormBuilder, FormGroup } from '@angular/forms';

// Create a variable called registrationForm of type FormGroup
// Your code here

Hint

Start by importing the necessary classes and declare the form variable.

2

Add form configuration with validation

Create a constructor that injects FormBuilder as fb and initialize registrationForm using fb.group() with controls username and email, both set to empty strings and marked as Validators.required.

Angular

import { FormBuilder, FormGroup, Validators } from '@angular/forms';

registrationForm: FormGroup;

constructor(private fb: FormBuilder) {
  // Initialize registrationForm with username and email controls with required validators
  // Your code here
}

Hint

Use fb.group() to create the form controls with validation.

3

Implement core reactive form logic

Add a method called submitForm() that checks if registrationForm is valid using this.registrationForm.valid and returns true if valid, otherwise false.

Angular

import { FormBuilder, FormGroup, Validators } from '@angular/forms';

registrationForm: FormGroup;

constructor(private fb: FormBuilder) {
  this.registrationForm = this.fb.group({
    username: ['', Validators.required],
    email: ['', Validators.required]
  });
}

// Add a method submitForm() that returns true if the form is valid
// Your code here

Hint

Create a method to check the form's validity before submission.

4

Complete the reactive form setup

Add the @Component decorator with selector set to 'app-registration' and standalone: true. Include imports with ReactiveFormsModule to enable reactive forms in the template.

Angular

// Add @Component decorator with selector 'app-registration', standalone true, and imports ReactiveFormsModule
// Your code here
import { Component } from '@angular/core';
import { ReactiveFormsModule } from '@angular/forms';
import { FormBuilder, FormGroup, Validators } from '@angular/forms';

registrationForm: FormGroup;

constructor(private fb: FormBuilder) {
  this.registrationForm = this.fb.group({
    username: ['', Validators.required],
    email: ['', Validators.required]
  });
}

submitForm() {
  return this.registrationForm.valid;
}

Hint

Use the @Component decorator to complete the Angular component setup for reactive forms.

Practice

1. Why are reactive forms preferred in Angular over template-driven forms?

easy

A. They provide better control and scalability for complex forms.

B. They require less code and are simpler for small forms.

C. They automatically generate UI without coding.

D. They do not support validation.

Solution

1. Step 1: Understand form control in Angular

   Reactive forms allow explicit creation and management of form controls in the component class, giving better control.

2. Step 2: Compare with template-driven forms

   Template-driven forms are simpler but less scalable and harder to manage for complex forms.

3. Final Answer:

   They provide better control and scalability for complex forms. -> Option A

4. Quick Check:

   Reactive forms = better control and scalability [OK]

Hint: Reactive forms = explicit control, best for complex forms [OK]

Common Mistakes:

• Thinking reactive forms are simpler for small forms
• Believing reactive forms auto-generate UI
• Assuming reactive forms lack validation

2. Which of the following is the correct way to create a reactive form control in Angular?

easy

A. this.form = new ControlGroup({ name: new FormControl('') });

B. this.form = new FormGroup({ name: new FormControl('') });

C. this.form = new FormGroupControl({ name: new FormControl('') });

D. this.form = new FormControlGroup({ name: new FormControl('') });

Solution

1. Step 1: Recall Angular reactive form syntax

   The correct class to create a group of controls is FormGroup, and individual controls use FormControl.

2. Step 2: Check the options for correct class names

   Only this.form = new FormGroup({ name: new FormControl('') }); uses the correct Angular classes: FormGroup and FormControl.

3. Final Answer:

   this.form = new FormGroup({ name: new FormControl('') }); -> Option B

4. Quick Check:

   FormGroup + FormControl = correct syntax [OK]

Hint: FormGroup holds controls; FormControl defines each input [OK]

Common Mistakes:

• Using incorrect class names like FormControlGroup
• Mixing up FormGroup and ControlGroup
• Omitting new keyword

3. Given this reactive form code snippet, what will be the output when console.log(this.form.value) is called after initialization?

this.form = new FormGroup({
  email: new FormControl(''),
  password: new FormControl('1234')
});

medium

A. { email: '', password: '1234' }

B. { email: null, password: null }

C. { email: undefined, password: '1234' }

D. Error: form not initialized

Solution

1. Step 1: Check initial values of form controls

   The email control is initialized with an empty string '', and password with '1234'.

2. Step 2: Understand form.value output

   Calling form.value returns an object with current values of each control.

3. Final Answer:

   { email: '', password: '1234' } -> Option A

4. Quick Check:

   form.value = current control values [OK]

Hint: form.value shows current control values as object [OK]

Common Mistakes:

• Assuming uninitialized controls are null or undefined
• Expecting error without initialization
• Confusing form.value with form.controls

4. Identify the error in this reactive form setup:

this.form = new FormGroup({
  username: FormControl('user1'),
  age: new FormControl(25)
});

medium

A. FormGroup should be FormControlGroup.

B. FormGroup cannot have more than one control.

C. Age control value must be a string, not a number.

D. FormControl is missing the 'new' keyword for username control.

Solution

1. Step 1: Check syntax for creating FormControl

   FormControl must be instantiated with 'new' keyword to create a control instance.

2. Step 2: Identify the incorrect usage

   Username control uses FormControl('user1') without 'new', causing a syntax/runtime error.

3. Final Answer:

   FormControl is missing the 'new' keyword for username control. -> Option D

4. Quick Check:

   Always use 'new FormControl()' to create controls [OK]

Hint: Remember: 'new' keyword is required for FormControl [OK]

Common Mistakes:

• Omitting 'new' before FormControl
• Using wrong class names like FormControlGroup
• Thinking numeric values are invalid for controls

5. You want to build a dynamic form where fields can be added or removed at runtime. Why is using reactive forms preferred in this case?

hard

A. Reactive forms do not support dynamic changes once initialized.

B. Template-driven forms automatically handle dynamic fields without code.

C. Reactive forms allow programmatic control to add or remove controls easily.

D. Template-driven forms provide better validation for dynamic fields.

Solution

1. Step 1: Understand dynamic form requirements

   Dynamic forms need adding/removing controls during runtime based on user actions.

2. Step 2: Compare reactive and template-driven forms

   Reactive forms provide APIs like addControl and removeControl for easy dynamic updates, while template-driven forms lack this flexibility.

3. Final Answer:

   Reactive forms allow programmatic control to add or remove controls easily. -> Option C

4. Quick Check:

   Dynamic forms = reactive forms for control [OK]

Hint: Use reactive forms for dynamic field control [OK]

Common Mistakes:

• Assuming template-driven forms handle dynamic fields automatically
• Believing reactive forms are static after creation
• Confusing validation capabilities between form types