Angular Forms năm 2026: Reactive Forms, Validation và Câu hỏi Phỏng vấn Kỹ thuật

import { Component, inject } from '@angular/core';
import { FormBuilder, Validators, ReactiveFormsModule } from '@angular/forms';
import { CommonModule } from '@angular/common';

@Component({
  selector: 'app-user-profile',
  standalone: true,
  imports: [CommonModule, ReactiveFormsModule],
  template: `
    <form [formGroup]="profileForm" (ngSubmit)="onSubmit()">
      <input formControlName="email" placeholder="Email" />
      <input formControlName="name" placeholder="Full Name" />
      <button type="submit" [disabled]="profileForm.invalid">Save</button>
    </form>
  `
})
export class UserProfileComponent {
  private fb = inject(FormBuilder);

  // Typed form with NonNullable configuration
  profileForm = this.fb.nonNullable.group({
    email: ['', [Validators.required, Validators.email]],
    name: ['', [Validators.required, Validators.minLength(2)]]
  });

  onSubmit() {
    // profileForm.getRawValue() returns typed object
    const data = this.profileForm.getRawValue();
    console.log(data.email, data.name); // Both are string, not string | null
  }
}

import { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';

// Synchronous validator: password strength
export function strongPassword(): ValidatorFn {
  return (control: AbstractControl): ValidationErrors | null => {
    const value = control.value;
    if (!value) return null;

    const hasUpperCase = /[A-Z]/.test(value);
    const hasLowerCase = /[a-z]/.test(value);
    const hasNumber = /\d/.test(value);
    const hasSpecial = /[!@#$%^&*]/.test(value);
    const isLongEnough = value.length >= 8;

    const valid = hasUpperCase && hasLowerCase && hasNumber && hasSpecial && isLongEnough;
    
    return valid ? null : {
      strongPassword: {
        hasUpperCase,
        hasLowerCase,
        hasNumber,
        hasSpecial,
        isLongEnough
      }
    };
  };
}

// Cross-field validator: password confirmation
export function passwordMatch(): ValidatorFn {
  return (group: AbstractControl): ValidationErrors | null => {
    const password = group.get('password')?.value;
    const confirm = group.get('confirmPassword')?.value;
    
    return password === confirm ? null : { passwordMismatch: true };
  };
}

@Component({
  selector: 'app-registration',
  standalone: true,
  imports: [CommonModule, ReactiveFormsModule],
  template: `
    <form [formGroup]="registrationForm" (ngSubmit)="register()">
      <input formControlName="password" type="password" />
      <input formControlName="confirmPassword" type="password" />
      
      @if (registrationForm.errors?.['passwordMismatch']) {
        <span class="error">Passwords do not match</span>
      }
    </form>
  `
})
export class RegistrationComponent {
  private fb = inject(FormBuilder);

  registrationForm = this.fb.nonNullable.group({
    password: ['', [Validators.required, strongPassword()]],
    confirmPassword: ['', Validators.required]
  }, { validators: passwordMatch() }); // Group-level validator
}

import { AbstractControl, AsyncValidatorFn, ValidationErrors } from '@angular/forms';
import { Observable, of, timer } from 'rxjs';
import { map, switchMap, catchError } from 'rxjs/operators';
import { inject } from '@angular/core';
import { UserService } from '../services/user.service';

export function uniqueEmailValidator(userService: UserService): AsyncValidatorFn {
  return (control: AbstractControl): Observable<ValidationErrors | null> => {
    if (!control.value) {
      return of(null);
    }

    // Debounce 300ms to avoid excessive API calls
    return timer(300).pipe(
      switchMap(() => userService.checkEmailAvailable(control.value)),
      map(isAvailable => isAvailable ? null : { emailTaken: true }),
      catchError(() => of(null)) // Fail open on network errors
    );
  };
}

@Component({
  selector: 'app-signup',
  standalone: true,
  imports: [CommonModule, ReactiveFormsModule],
  template: `
    <form [formGroup]="signupForm">
      <input formControlName="email" />
      @if (emailControl.pending) {
        <span>Checking availability...</span>
      }
      @if (emailControl.errors?.['emailTaken']) {
        <span class="error">This email is already registered</span>
      }
    </form>
  `
})
export class SignupComponent {
  private fb = inject(FormBuilder);
  private userService = inject(UserService);

  signupForm = this.fb.nonNullable.group({
    email: ['', 
      [Validators.required, Validators.email],
      [uniqueEmailValidator(this.userService)] // Async validator as 3rd argument
    ]
  });

  get emailControl() {
    return this.signupForm.controls.email;
  }
}

import { Component, inject } from '@angular/core';
import { FormBuilder, FormArray, ReactiveFormsModule, Validators } from '@angular/forms';
import { CommonModule } from '@angular/common';

@Component({
  selector: 'app-order-form',
  standalone: true,
  imports: [CommonModule, ReactiveFormsModule],
  template: `
    <form [formGroup]="orderForm">
      <div formArrayName="items">
        @for (item of itemsArray.controls; track item; let i = $index) {
          <div [formGroupName]="i" class="item-row">
            <input formControlName="productName" placeholder="Product" />
            <input formControlName="quantity" type="number" />
            <input formControlName="price" type="number" />
            <button type="button" (click)="removeItem(i)">Remove</button>
          </div>
        }
      </div>
      <button type="button" (click)="addItem()">Add Item</button>
      <p>Total: {{ calculateTotal() | currency }}</p>
    </form>
  `
})
export class OrderFormComponent {
  private fb = inject(FormBuilder);

  orderForm = this.fb.group({
    items: this.fb.array<FormGroup>([])
  });

  get itemsArray(): FormArray {
    return this.orderForm.get('items') as FormArray;
  }

  addItem() {
    const itemGroup = this.fb.nonNullable.group({
      productName: ['', Validators.required],
      quantity: [1, [Validators.required, Validators.min(1)]],
      price: [0, [Validators.required, Validators.min(0)]]
    });
    this.itemsArray.push(itemGroup);
  }

  removeItem(index: number) {
    this.itemsArray.removeAt(index);
  }

  calculateTotal(): number {
    return this.itemsArray.controls.reduce((sum, control) => {
      const quantity = control.get('quantity')?.value || 0;
      const price = control.get('price')?.value || 0;
      return sum + (quantity * price);
    }, 0);
  }
}

import { Component, signal, computed } from '@angular/core';
import { SignalFormControl } from '@angular/forms';

@Component({
  selector: 'app-signal-form',
  standalone: true,
  template: `
    <input [value]="name()" (input)="name.set($any($event.target).value)" />
    <p>Character count: {{ charCount() }}</p>
    <p>Valid: {{ isValid() }}</p>
  `
})
export class SignalFormExampleComponent {
  // Signal-based form state
  name = signal('');
  
  // Computed values automatically update
  charCount = computed(() => this.name().length);
  isValid = computed(() => this.name().length >= 3);
}

// Reset entire form to initial values
this.form.reset(); // All controls become null (or default if nonNullable)

// Reset with specific values
this.form.reset({ email: '', name: 'Guest' });

// Reset single control
this.form.controls.email.reset();

// Mark as pristine without changing values
this.form.markAsPristine();
this.form.markAsUntouched();

// setValue requires ALL controls - throws if missing any
this.form.setValue({ email: 'a@b.com', name: 'Test' }); // Must include both

// patchValue allows partial updates
this.form.patchValue({ email: 'a@b.com' }); // Name unchanged

this.form.controls.email.disable();
console.log(this.form.value); // { name: 'Test' } - email missing

// Use getRawValue() to include disabled controls
console.log(this.form.getRawValue()); // { email: 'a@b.com', name: 'Test' }

import { Component, input } from '@angular/core';
import { AbstractControl, ValidationErrors } from '@angular/forms';

@Component({
  selector: 'app-form-errors',
  standalone: true,
  template: `
    @if (control().invalid && (control().dirty || control().touched)) {
      <div class="errors" role="alert">
        @if (control().errors?.['required']) {
          <span>This field is required</span>
        }
        @if (control().errors?.['email']) {
          <span>Enter a valid email address</span>
        }
        @if (control().errors?.['minlength']) {
          <span>Minimum {{ control().errors?.['minlength'].requiredLength }} characters</span>
        }
      </div>
    }
  `
})
export class FormErrorsComponent {
  control = input.required<AbstractControl>();
}