Angular glossary

106 Angular terms, from Novice to Master. Start with the basics or jump to a level.

Updated

Novice

@Component
The decorator that marks a class as an Angular component and gives its selector, template, styles and imports.
Angular
A Google framework for building web apps in TypeScript, with most tools built in.
Angular CLI
The `ng` command-line tool for creating, running, testing and building Angular apps.
angular.json
The file that tells the Angular CLI how to build and serve the app: its styles, output folder and settings.
Component
A building block of an Angular page: a class plus its HTML template.
Component Styles
CSS that belongs to one component and doesn't leak into others.
Event Binding
The `( )` syntax that runs component code when an event happens.
Interpolation
The `{{ }}` syntax that shows a component value in the template.
ng build
The Angular CLI command that builds the app's small, fast production files, ready to publish.
ng generate
The Angular CLI command that adds a new part, such as a component or service, with its files.
ng new
The CLI command that creates a new Angular project.
ng serve
The CLI command that runs the app locally and reloads it when files change.
Property Binding
The `[ ]` syntax that sets an element property from a component value.
Selector
The custom HTML tag used to place a component on a page.
Standalone Component
A component that declares its own imports without needing an NgModule; the modern default.
Template
The HTML part of a component, with Angular syntax for data and events.
TypeScript in Angular
Angular uses TypeScript, which adds types to JavaScript to catch mistakes early.

Apprentice

@for
Template syntax that repeats a block for every item in a list.
@if
Template syntax that shows a block only when a condition is true.
@Service
The Angular 22 decorator that marks a class as a service, with one instance shared by everyone who injects it.
@switch
Template syntax that shows one of several blocks based on a value.
Built-in Pipes
Ready-made pipes like date, currency, uppercase and json.
Class and Style Binding
Binding syntax that adds CSS classes or styles based on component values.
Content Projection
Passing HTML into a child component, which shows it where `<ng-content />` is.
Dependency Injection
Angular's system for handing classes the services they need.
Directive
An instruction attached to an element that changes how it looks or behaves.
HttpClient
Angular's service for calling web APIs.
inject()
The function that asks Angular for a service.
input()
Declares a value a parent component can pass into this component.
Lifecycle Hook
A method Angular calls at key moments, like when a component starts or is removed.
navigate()
The Router method that goes to another page from code, such as after a form is saved.
ngModel
The directive from FormsModule that ties a form field to a component value, usually as [(ngModel)].
ngOnDestroy
The lifecycle hook Angular calls just before a component is removed; used to stop timers and clean up.
ngOnInit
The lifecycle hook that runs once when a component is ready; often used to load data.
output()
Declares an event that a component sends up to its parent.
Pipe
A template formatter used with `|`, such as for dates or prices.
Route
A mapping from a URL path to the component to show.
Router
The part of Angular that shows different components for different URLs.
Router Outlet
The placeholder where the router shows the current route's component.
routerLink
A directive that makes an element navigate to another route without a page reload.
routerLinkActive
A directive that adds a CSS class to a link while the link's page is showing.
Service
A shared class for logic or data used by many components.
Template Reference Variable
A `#name` label on an element so the template can refer to it.
Two-Way Binding
The `[( )]` syntax that keeps a field and a component value in sync both ways.
Wildcard Route
The ** route that matches any address; put last, it shows a page-not-found page.

Journeyman

@defer
Template syntax that loads a block and its code only when needed.
ActivatedRoute
A service that describes the route a component was opened by, including its route and query parameters.
asReadonly()
Gives a read-only view of a writable signal: others can read it, but only its owner can change it.
async Pipe
A pipe that subscribes to an Observable in the template and cleans up automatically.
Attribute Directive
A directive that changes the look or behavior of an existing element.
Component Input Binding
A router setting that hands a page's route and query parameters to its component as inputs.
computed()
Creates a signal whose value is calculated from other signals.
Custom Pipe
Your own template formatter, written as a class with a `transform` method.
Dev Server Proxy
A setting that makes ng serve pass the app's /api requests on to the API, so the browser sees one address.
effect()
Runs code whenever the signals it reads change.
Environment Files
Files holding settings that differ between development and production builds.
FormControl
Tracks the value and validity of a single form field.
FormGroup
Bundles several form controls so the form has one value and validity.
Interceptor
A function that sees every HTTP request and response in one place.
Lazy Loading
Downloading parts of the app only when the user first needs them.
Observable
A stream of values over time; nothing happens until someone subscribes.
Prop Drilling
Passing data down through components that don't use it, just so it reaches one deeper down.
Providers
Registrations that tell Angular how to create the services it injects.
Query Parameter
An optional name=value pair after the ? in an address that a page reads, such as a filter or a page number.
Reactive Forms
Forms whose structure and rules are defined in TypeScript code.
Route Guard
A function that decides whether navigation to a route is allowed.
Route Parameter
A changing part of a URL, like an ID, that the component can read.
RxJS
The library of Observables that Angular uses for values arriving over time.
Signal
A value that notifies Angular when it changes so the page updates.
subscribe()
Starts an Observable and handles each value it delivers.
tap
An RxJS operator that does something with each value, such as saving it, and passes it on unchanged.
Template-Driven Forms
Forms defined mainly in the template using `ngModel`.
Validator
A rule that checks a form field's value, like required or email.
ViewChild
Gives a component a reference to an element or child in its own template.

Freelancer

Async Validator
A form rule that checks a value asynchronously, such as with a server call.
Change Detection
How Angular works out which parts of the page to redraw after a change.
Component Harness
A test helper that interacts with a component like a user, hiding its inner HTML.
Custom Validator
Your own form rule: returns null when valid or an error object when not.
Hierarchical Injector
Angular's layered injectors: app, route and component, each able to provide its own copy.
Hydration
Angular taking over server-rendered HTML in the browser without redrawing it.
Injection Token
A key for injecting values that aren't classes, like settings.
linkedSignal()
A writable signal that resets when a source signal changes.
NgModule
The older way of grouping Angular pieces and their dependencies; replaced by standalone components.
OnPush
A setting that re-checks a component only when its inputs, events or signals change.
Resolver
A function that loads data before a route opens.
resource()
Loads async data into signals, with loading and error states, and reloads on change.
RxJS Operators
Functions chained with `pipe()` to transform an Observable stream.
Server-Side Rendering
Building the page HTML on the server so content shows before the JavaScript loads.
Subject
An Observable you can push values into yourself.
switchMap
An operator that switches to a new Observable for each value, cancelling the previous one.
TestBed
Angular's test helper that builds a small app environment for a component under test.
toSignal()
Turns an Observable into a signal.
Zone.js
A library older Angular apps use to trigger change detection after async work.
Zoneless Angular
Running Angular without Zone.js, relying on signals and events to trigger updates.

Master

Ahead-of-Time Compilation
Compiling templates into JavaScript during the build rather than in the browser.
Angular Elements
Packaging an Angular component as a Web Component usable in any page.
Custom Structural Directive
Your own directive that adds or removes template blocks.
Host Directive
Automatically applying other directives to a component to reuse behavior.
Incremental Hydration
Hydrating server-rendered sections only when they are needed.
Ivy
Angular's compiler and rendering engine.
Micro Frontend
A section of a site built and deployed on its own, then combined with others in the browser.
Module Federation
Letting separately built apps load each other's code at run time.
NgRx
A state management library for Angular that centralizes app state.
Schematics
Code generators run by the Angular CLI, such as `ng generate`.
Signal Store
A lightweight NgRx state store built on signals.
Tree Shaking
Removing unused code from the final build.

More subjects in Front-End Frameworks