Typed reactive forms
Strictly typed FormGroup<T> — and what untyped reactive forms were quietly letting slip past the compiler.
Typed reactive forms
The player loads from youtube-nocookie.com when you press play. Nothing reaches YouTube before that.
Not started
What you'll learn
- Before typed forms, `form.get('name')` and `form.value` were both typed as `any` — a typo in a control's name, or a wrong assumption about its shape, failed silently at runtime instead of being caught at compile time.
- A typed `FormGroup<T>` gives you a real, checked type for the whole form's value and every individual control's value, inferred automatically from how the group was constructed.
- Migrating is mostly mechanical: Angular's generated types mostly just work once you stop treating `form.value` and `form.get()` as `any` — the main adjustment is handling that some fields can legitimately be `null` or partial during the form's lifecycle.
What untyped reactive forms were quietly getting wrong
Every reactive form example so far has worked, and worked correctly — but
there’s a gap this lesson closes that’s easy to miss until it bites you. Before
typed forms, a FormGroup’s .value and .get() were both typed as any.
That’s not a cosmetic detail: it means a typo in a control’s name, or a wrong
assumption about what shape form.value actually has, compiles without
complaint and fails — if it fails at all — only at runtime, often somewhere far
from where the mistake was actually made.
// untyped: this compiles fine even though 'emial' is misspelled
const email = this.profileForm.get('emial')?.value;
TypeScript is supposed to catch exactly this class of mistake. Reactive forms, for a long stretch of Angular’s history, simply opted the whole form out of that protection.
A real, inferred type for the whole form
profileForm = this.fb.group({
name: [''],
email: [''],
});
// profileForm is now FormGroup<{ name: FormControl<string | null>; email: FormControl<string | null>; }>
Current Angular infers a strict type for the group automatically from how it
was built — no separate interface to hand-write and keep in sync. .get('name')
is now checked against the group’s real, known keys; misspell it, and you get a
compile-time error instead of a silent null. .value has an actual, specific
shape TypeScript can check your code against, instead of any papering over
whatever assumptions you happened to make.
const email = this.profileForm.get('emial')?.value;
// ^ compile error: 'emial' doesn't exist on this FormGroup's controls
The nullability is real, not a typing inconvenience
One adjustment typed forms force on you: fields often type as
string | null, not just string. That’s not the type system being
pedantic — it reflects genuine possibilities an untyped form let you ignore.
Reset a control and its value can become null. A control can be disabled, in
which case .value on the enclosing group excludes it entirely by default. A
FormArray’s length changes at runtime, so a specific index may not exist by
the time you read it. Typed forms make you handle these cases explicitly,
instead of letting any quietly hide them until one shows up in production as
an unexplained runtime error.
Migrating an existing form
For most existing reactive forms, migrating to the typed API is closer to
mechanical than to a rewrite — Angular’s own inference does most of the work the
moment you stop explicitly typing things as any yourself, and the main real
effort is auditing the places your code assumed a value could never be null
when, honestly, it always could have been. This lesson’s video walks through
exactly that kind of upgrade on a real form, which is the clearest way to see
what actually needs to change versus what simply starts being checked that
wasn’t before. The linked “deeper” video covers the same ground with its own
worked example if a second pass helps it stick.
Check yourself
In an untyped reactive form, what happens if you write `this.profileForm.get('emial')` — misspelling the control's name — and what would happen with a typed form instead?
With an untyped form, `.get('emial')` compiles fine (the argument is just a string) and returns `null` at runtime with no warning — the typo surfaces only when something downstream unexpectedly breaks. With a typed `FormGroup<T>`, `.get()` is checked against the group's actual known keys, so misspelling the control's name is a compile-time type error, not a silent runtime surprise.
Why might a typed form's `value` property have some fields marked optional or nullable, even though every control was given a default value when the form was built?
Angular's typed forms account for the real lifecycle of a form — a control can be removed from a FormGroup, disabled controls are excluded from `.value` by default, and a FormArray's length can change — so the generated type reflects those genuine possibilities rather than pretending every field is always guaranteed to be present.
Go deeper
Notes
Notes are saved to your account.
Everything else on this page works without one — progress and bookmarks keep themselves in this browser and come with you when you sign in. Notes are the one thing worth not trusting to a browser you might clear.
Your notes could not be loaded.