Angular Fundamentals
Angular is a TypeScript-based web application framework maintained by Google. It provides a component architecture, dependency injection, reactive forms, routing, and a CLI toolchain for building structured single-page applications.
itWeb development | OpenSkills.info
Intro
Angular Fundamentals
Angular is a web framework for building applications with TypeScript, HTML, and CSS. It gives you one integrated system for user interfaces, navigation, forms, server communication, testing, and build tooling.
That integration is Angular's central tradeoff. You adopt more structure than a small view library requires. In return, teams get shared conventions and first-party solutions for common application problems.
Angular works well when an application has many screens, substantial user interaction, or a team that benefits from consistent patterns. A small static page may not need a framework. A content-heavy site may need server rendering or prerendering rather than client-only rendering.
Think in component trees
An Angular application is a tree of components. Each component owns a part of the page and the behavior behind it.
A component has three core parts:
- A TypeScript class holds state and behavior.
- An HTML template describes the rendered view.
- A selector identifies the component in another template.
The @Component decorator adds Angular metadata to the class. Modern Angular components are standalone by default. A standalone component lists the components, directives, and pipes used by its template in its own imports array.
import {Component, signal} from '@angular/core';
@Component({
selector: 'app-counter',
template: `
<button type="button" (click)="increment()">
Count: {{ count() }}
</button>
`,
})
export class Counter {
count = signal(0);
increment() {
this.count.update(value => value + 1);
}
}
This example contains the basic Angular loop. State lives in the class. The template reads that state. An event calls a class method. Angular updates the affected view when the state changes.
Continue the course
This section is part of the paid course.
See pricing to subscribe, or log in if you already have access.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://angular.dev/overview
Supports
- Angular as an integrated web framework maintained by Google
- First-party components, signals, rendering, dependency injection, routing, forms, tooling, security, and update support
- Angular documentation as the official reference
- https://angular.dev/essentials
Supports
- Beginner progression through components, templates, signals, inputs, outputs, control flow, and dependency injection
- Official foundational learning path used in the links progression
- https://angular.dev/guide/components
Supports
- Component class, template, selector, metadata, host element, and view
- Applications composed as component trees
- Standalone components and component-level imports
- https://angular.dev/guide/templates
Supports
- Angular templates as HTML extended with binding, events, variables, and control flow
- Template compilation and automatic rendered updates
- Special meanings of square brackets, parentheses, and control-flow syntax
- https://angular.dev/guide/templates/event-listeners
Supports
- Parentheses syntax for event listeners
- Execution of template statements in response to DOM events
- https://angular.dev/guide/signals
Supports
- Writable and read-only signals
- Getter calls, tracked reads, reactive contexts, computed values, and effects
- Signal updates and dependency-driven consumer execution
- https://angular.dev/guide/di
Supports
- Dependencies supplied to consumers instead of constructed internally
- Services, providers, injection contexts, and the inject function
- Reuse, separation of concerns, and testing through replacement dependencies
- https://angular.dev/guide/routing
Supports
- Routes, outlets, and links as the three primary router parts
- Parameters, nested routes, navigation, lazy loading, and guards
- Client navigation without a full page reload
- https://angular.dev/guide/routing/route-guards
Supports
- Route guards controlling navigation attempts
- Explicit warning against relying on client-side guards as the sole access-control mechanism
- Server-side authorization for protected resources
- https://angular.dev/guide/forms
Supports
- Signal Forms, Reactive Forms, and Template-driven Forms
- Reactive Forms as explicit, synchronous, scalable, reusable, and testable
- Template-driven Forms as a fit for simple form requirements
- https://angular.dev/guide/http
Supports
- HttpClient as Angular's backend communication API
- Typed responses, interception, error handling, and testing utilities
- https://angular.dev/guide/http/making-requests
Supports
- HttpClient methods and observable responses
- Cold request observables sending a request for each subscription
- Request options, response handling, errors, and cancellation
- https://angular.dev/guide/http/testing
Supports
- HTTP test backend and HttpTestingController
- Capturing requests, asserting behavior, flushing responses, and checking for unexpected traffic
- https://angular.dev/guide/testing
Supports
- Vitest as the default test setup for new Angular CLI projects
- The ng test workflow, DOM test environments, coverage, and browser execution
- Angular testing configuration and boundaries
- https://angular.dev/guide/routing/testing
Supports
- RouterTestingHarness for routed component tests
- Testing navigation state, parameters, guards, and error scenarios
- Avoiding router mocks when a real test configuration is suitable
- https://angular.dev/tools/cli
Supports
- Angular CLI scaffolding, development, testing, deployment, and maintenance role
- The ng command and official command reference
- https://angular.dev/tools/cli/build
Supports
- ng build compilation, bundling, minification, builders, and output
- Application build configuration and size budgets
- https://angular.dev/best-practices/performance/ssr
Supports
- Client-side, server-side, prerendered, and hybrid route rendering
- Hydration constraints and server-client output consistency
- Server route configuration, browser-only code boundaries, caching, and deployment tradeoffs
- https://angular.dev/best-practices/a11y
Supports
- Native element preference, ARIA bindings, focus management, and router navigation concerns
- Angular CDK and Angular Aria accessibility tools
- Deferred-content announcements and assistive-technology considerations
- https://angular.dev/best-practices/security
Supports
- Bound values treated as untrusted and sanitized by DOM security context
- Trusted executable templates and danger of user-generated template code
- Direct DOM risks, bypass APIs, AOT, Content Security Policy, and Trusted Types
- Framework protection boundary excluding application authentication and authorization
