Skip to content

Angular Шпаргалка

Фреймворк для веб-приложений на TypeScript от Google.

01

Начало работы

Установка CLI и создание проекта

Angular CLI — главный инструмент разработки. ng new создаёт полный проект с преднастроенной маршрутизацией и стилями. Используйте ng generate (ng g) для единообразного создания файлов. CLI отвечает за сборку, тестирование и развёртывание.

angular
# install Angular CLI globally
npm install -g @angular/cli

# create a new project
ng new my-app --routing --style=scss
cd my-app

# serve the app (default: localhost:4200)
ng serve --open

# generate components, services, etc.
ng generate component components/user-profile
ng g service services/auth
ng g module modules/admin --routing

Обзор структуры проекта

Angular навязывает понятную структуру папок. src/app содержит весь код фич. main.ts запускает корневой компонент. angular.json настраивает опции сборки, тестов и запуска. Папка environments позволяет подменять URL API в зависимости от окружения.

angular
my-app/
├── src/
│   ├── app/                 # application code lives here
│   │   ├── app.component.ts
│   │   ├── app.component.html
│   │   └── app.config.ts    # standalone bootstrap config
│   ├── assets/              # static images, fonts
│   ├── environments/        # env-specific values
│   ├── index.html           # main HTML entry
│   ├── main.ts              # bootstrap entry point
│   └── styles.scss          # global styles
├── angular.json             # CLI workspace config
├── package.json
└── tsconfig.json

Запуск и сборка

ng serve запускает dev-сервер с перезагрузкой в стиле HMR на порту 4200 по умолчанию. Продакшен-сборка выполняет tree-shaking, минификацию и добавляет хеши в имена файлов для кеширования. Используйте --stats-json вместе с webpack-bundle-analyzer, чтобы найти раздутые зависимости. ng test по умолчанию запускает Karma.

angular
# dev server with live reload
ng serve --port 4300 --open

# production build (outputs to dist/)
ng build --configuration production

# analyze bundle size
ng build --stats-json
npx webpack-bundle-analyzer dist/my-app/stats.json

# run unit tests (Karma + Jasmine)
ng test

# run end-to-end tests
ng e2e

Генерация кода (Schematics)

Schematics обеспечивают единообразное именование файлов и шаблонный код. Флаг --standalone генерирует standalone-компоненты (рекомендуется с v17). --route + --module автоматически настраивают лениво загружаемый маршрут. Гварды, созданные с --functional, возвращают функцию вместо класса.

angular
# generate a standalone component
ng g component user-profile --standalone

# generate a service with root provider
ng g service services/auth

# generate a guard (functional by default)
ng g guard guards/auth --functional

# generate a pipe, directive, or module
ng g pipe pipes/shorten
ng g directive directives/highlight
ng g module admin --routing --route admin --module app

# generate an interface or enum
ng g interface models/user
ng g enum models/role

Конфигурация (angular.json)

angular.json — конфигурация рабочего пространства. У каждого проекта есть цели build, serve, test и lint. budgets выдают предупреждение или ошибку, когда бандлы превышают лимиты. Массив polyfills включает zone.js, необходимый Angular. В одном workspace могут сосуществовать несколько проектов (приложение + библиотека).

angular
{
  "projects": {
    "my-app": {
      "architect": {
        "build": {
          "options": {
            "outputPath": "dist/my-app",
            "index": "src/index.html",
            "main": "src/main.ts",
            "polyfills": ["zone.js"],
            "tsConfig": "tsconfig.app.json",
            "assets": ["src/favicon.ico", "src/assets"],
            "styles": ["src/styles.scss"],
            "scripts": []
          },
          "configurations": {
            "production": {
              "budgets": [{ "type": "initial", "maximumWarning": "500kb" }]
            }
          }
        }
      }
    }
  }
}

Окружения (Environments)

Angular подменяет файлы окружений при сборке в зависимости от конфигурации (dev или prod). Подмена файлов настраивается в angular.json через fileReplacements. Внедрите объект environment в любом месте, чтобы получить значения конкретного окружения без жёстко прописанных URL. Никогда не коммитьте реальные секреты в систему контроля версий.

angular
// src/environments/environment.ts
export const environment = {
  production: false,
  apiUrl: 'http://localhost:3000/api',
  apiKey: 'dev-key'
};

// src/environments/environment.prod.ts
export const environment = {
  production: true,
  apiUrl: 'https://api.example.com',
  apiKey: 'prod-key'
};

// usage in a service
import { environment } from '../environments/environment';

@Injectable({ providedIn: 'root' })
export class ApiService {
  private baseUrl = environment.apiUrl;
}
02

Основы компонентов

Базовый компонент

Компонент — это TypeScript-класс с декоратором @Component. selector — кастомный HTML-тег, используемый в шаблонах. templateUrl/styleUrls ссылаются на внешние файлы; для инлайновых — template/styles. @Input помечает свойства, к которым могут привязываться родители. Держите компоненты сосредоточенными на одной задаче.

angular
// user-profile.component.ts
import { Component, Input } from '@angular/core';

@Component({
  selector: 'app-user-profile',
  templateUrl: './user-profile.component.html',
  styleUrls: ['./user-profile.component.scss'],
})
export class UserProfileComponent {
  @Input() name = 'Guest';
  @Input() age = 0;

  greet() {
    return `Hello, ${this.name}!`;
  }
}

Компонент со встроенным шаблоном

Инлайновые шаблоны удобны для небольших компонентов и избавляют от лишних файлов. Для многострочных строк используйте бэктики — внутренние экранируйте как \`. styles принимает массив CSS-строк. Селектор :host нацелен на собственный элемент компонента. Как только шаблон вырастает примерно до 10 строк, переходите на внешние файлы.

angular
@Component({
  selector: 'app-counter',
  template: `
    <button (click)="decrement()">-</button>
    <span>{{ count }}</span>
    <button (click)="increment()">+</button>
  `,
  styles: [`
    :host { display: flex; gap: 8px; align-items: center; }
    button { padding: 4px 12px; }
  `],
})
export class CounterComponent {
  count = 0;
  increment() { this.count++; }
  decrement() { this.count--; }
}

Standalone-компонент (v14+)

Standalone-компоненты не требуют NgModule — они сами объявляют массив imports с зависимостями (CommonModule, FormsModule, другие компоненты). Это современный рекомендуемый подход. Импортируйте только то, что используете, для лучшего tree-shaking. Bootstrap standalone-компонентов выполняется прямо в main.ts.

angular
import { Component } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormsModule } from '@angular/forms';

@Component({
  selector: 'app-search',
  standalone: true,
  imports: [CommonModule, FormsModule],
  template: `
    <input [(ngModel)]="query" placeholder="Search..." />
    <p>Searching for: {{ query }}</p>
  `,
})
export class SearchComponent {
  query = '';
}

Inputs и Outputs

@Input позволяет родителям передавать данные через привязку свойств. @Output открывает EventEmitter, на который родители подписываются через привязку событий. Всегда инициализируйте входы значениями по умолчанию, чтобы избежать ошибок undefined. В v17+ используйте новый signals-API input()/output() для более чистого кода.

angular
@Component({
  selector: 'app-toggle',
  template: `
    <button (click)="toggle()">{{ label }}: {{ on ? 'On' : 'Off' }}</button>
  `,
})
export class ToggleComponent {
  @Input() label = 'Toggle';
  @Input() on = false;
  @Output() changed = new EventEmitter<boolean>();

  toggle() {
    this.on = !this.on;
    this.changed.emit(this.on);
  }
}

<!-- parent template -->
<app-toggle [label]="'Power'" [on]="isOn" (changed)="onToggle($event)" />

Signal-входы (v17.1+)

Функция input() создаёт signal-вход, доступный только для чтения, который вызывается как функция. Она поддерживает обязательные входы через input.required<T>(), трансформации и бесшовно работает с computed() и effect(). output() — современная замена @Output EventEmitter. Это будущее Angular-компонентов.

angular
import { Component, input, output } from '@angular/core';

@Component({
  selector: 'app-card',
  template: `
    <div>{{ title() }} - {{ count() }}</div>
    <button (click)="clicked.emit()">Click</button>
  `,
})
export class CardComponent {
  // readonly signal inputs with defaults
  title = input<string>('Default');
  count = input<number>(0);

  // output() function replaces @Output
  clicked = output<void>();

  // computed derived from inputs
  // requires import { computed }
  // label = computed(() => this.title().toUpperCase());
}

Инкапсуляция представления

Emulated (по умолчанию) добавляет уникальные атрибуты, ограничивая стили компонентом без настоящего Shadow DOM. None делает стили глобальными (используйте редко). ShadowDom задействует нативный Shadow DOM для полной изоляции, но влияет на проникновение стилей и некоторые сторонние библиотеки. Придерживайтесь Emulated, пока нет особых требований.

angular
@Component({
  selector: 'app-styles',
  template: `<p class="local">Emulated (default)</p>`,
  styles: [`p.local { color: red; }`],
  encapsulation: ViewEncapsulation.Emulated, // default
})
export class StylesComponent {}

// ViewEncapsulation.None    -> styles leak globally
// ViewEncapsulation.ShadowDom -> real Shadow DOM (strong isolation)
// ViewEncapsulation.Emulated -> scoped attributes (default, recommended)
03

Синтаксис шаблонов

Текстовая интерполяция

Двойные фигурные скобки {{ }} выводят выражения как текст с HTML-экранированием. Доступно большинство JS-выражений: арифметика, тернарный оператор, вызовы методов, доступ к свойствам. Нет new, typeof или операторов присваивания. Пайпы (|) преобразуют вывод. Интерполяция пересчитывается на каждом цикле обнаружения изменений.

angular
<p>{{ title }}</p>                       <!-- renders the value -->
<p>{{ 1 + 2 }}</p>                        <!-- expressions allowed -->
<p>{{ user.name }}</p>                    <!-- property access -->
<p>{{ items.length }}</p>                 <!-- method/property -->
<p>{{ price | currency:'USD' }}</p>       <!-- pipe in interpolation -->
<p>{{ isReady ? 'Yes' : 'No' }}</p>       <!-- ternary -->

<!-- one-time interpolation updates when the source changes -->
<!-- new control flow @if, @for work without *ngIf/*ngFor directives -->

Привязка свойств и атрибутов

[prop] привязывается к DOM-свойству (предпочтительно). [attr.name] — к HTML-атрибутам, когда DOM-свойства нет (colspan, SVG-атрибуты). [class.x] переключает один класс по истинности; [style.prop] задаёт стиль с необязательным суффиксом единицы, например .px или %. Избегайте привязки innerHTML к недоверенному содержимому.

angular
<!-- property binding: [prop]="expression" -->
<img [src]="user.avatar" [alt]="user.name" />
<button [disabled]="isSaving">Save</button>
<my-comp [data]="items"></my-comp>

<!-- attribute binding (for attrs without DOM props) -->
<td [attr.colspan]="2">Merged cell</td>
<svg [attr.viewBox]="box"></svg>

<!-- class & style binding -->
<div [class.active]="isActive">Active?</div>
<div [class]="dynamicClassString">
<div [style.color]="colorVar">
<div [style.width.px]="size">Width</div>

Привязка событий

(event) привязывается к DOM-событиям и к кастомным EventEmitter. $event — полезная нагрузка события (DOM Event для нативных событий, переданное значение для кастомных). Модификаторы событий вроде .enter, .esc, .prevent, .stop фильтруют или преобразуют события. Цель в скобках определяет, что вызывает обработчик.

angular
<button (click)="save()">Save</button>
<input (input)="onInput($event)" (keyup)="onKey($event)" />
<div (mouseenter)="hover=true" (mouseleave)="hover=false">Hover</div>

<!-- $event is the DOM event object -->
<input (keyup.enter)="submit()" (keyup.esc)="cancel()" />

<!-- passive events (scroll, touchmove) -->
<div (scroll.passive)="onScroll($event)">...</div>

<!-- binding to custom component outputs -->
<app-child (changed)="onChanged($event)"></app-child>

Ссылочные переменные шаблона

#var (или ref-var) ссылается на DOM-элемент или экземпляр компонента, на котором объявлена. Доступна в любом месте шаблона. Для компонентов значение — экземпляр компонента; для элементов — HTMLElement. Внутри @for доступны неявные переменные контекста $index, $first, $last, $even, $odd.

angular
<input #nameInput type="text" />
<button (click)="nameInput.focus()">Focus</button>
<p>You typed: {{ nameInput.value }}</p>

<!-- ref to a component instance -->
<app-form #f="appForm"></app-form>
<button [disabled]="!f.valid" (click)="f.submit()">Submit</button>

<!-- ref inside @for -->
<ul>
  @for (item of items; track item.id) {
    <li>{{ item.name }} (index: {{ $index }})</li>
  }
</ul>

Двусторонняя привязка («банан в коробке»)

[(ngModel)] требует FormsModule. Синтаксис [(x)] разворачивается в [x] + (xChange), поэтому для кастомной двусторонней привязки нужен input с именем x и output с именем xChange. Запомните мнемонику «банан в коробке» — скобки внутри квадратных скобок. Signal-функция model() упрощает это в v17.2+.

angular
<!-- [()] = "banana in a box" - property + event combined -->
<input [(ngModel)]="username" />

<!-- equivalent to -->
<input [ngModel]="username" (ngModelChange)="username = $event" />

<!-- two-way binding on custom components -->
<app-counter [(value)]="count"></app-counter>
<!-- requires: @Input() value; @Output() valueChange = new EventEmitter() -->

<!-- signals: model() for two-way (v17.2+) -->
// value = model<number>(0);

Безопасная навигация и non-null

Оператор ?. безопасно проходит по цепочке nullable-значений, возвращая undefined вместо исключения. Используйте его для асинхронных данных, которые ещё не загружены. Оператор ! — только утверждение времени компиляции: он не добавляет проверок в runtime, применяйте только при полной уверенности. Для массивов, которые могут быть null, используйте запасной вариант ?? [].

angular
<!-- safe navigation: short-circuits to undefined if null -->
<p>{{ user?.profile?.bio }}</p>
<p>{{ user?.getName?.() }}</p>

<!-- non-null assertion: tells compiler it's not null -->
<p>{{ user!.name }}</p>

<!-- in property bindings -->
<img [src]="user?.avatar" />
<app-detail [data]="user!"></app-detail>

<!-- safe navigation in @for doesn't replace track -->
@for (item of items ?? []; track item.id) { ... }
04

Директивы

@if / @else (новый control flow)

Новый блочный синтаксис @if/@else if/@else заменяет *ngIf. Не нужен импорт CommonModule или NgIf, нет звёздочки, и @else работает нативно (в отличие от хака ngIf с ng-template). Это рекомендуемый синтаксис для нового кода. Часть встроенного control flow, появившегося в v17 и стабилизированного в v18.

angular
@if (user) {
  <p>Hello, {{ user.name }}</p>
} @else if (loading) {
  <p>Loading...</p>
} @else {
  <p>No user found.</p>
}

<!-- no structural directive import needed, no * prefix -->
<!-- works in standalone templates automatically (v17+) -->

@for / @empty (новый control flow)

@for заменяет *ngFor с обязательным выражением track для эффективного сравнения DOM. @empty рендерит запасное содержимое, когда коллекция пуста. Неявные переменные контекста ($index, $first, $last и др.) доступны всегда. Отслеживание по стабильному уникальному id критично для производительности больших списков.

angular
<ul>
  @for (item of items; track item.id) {
    <li>{{ item.name }} ({{ $index }})</li>
  } @empty {
    <li>No items yet.</li>
  }
</ul>

<!-- 'track' is REQUIRED for performance -->
<!-- implicit vars: $index, $first, $last, $even, $odd, $count -->

<!-- @for over a range -->
@for (i of [1,2,3,4,5]; track i) {
  <span>{{ i }}</span>
}

ngClass и ngStyle

ngClass принимает объект (применяются ключи с истинным значением), массив или строку. ngStyle принимает объект с ключами в camelCase или kebab-case и необязательными суффиксами единиц. Требует импорта CommonModule или конкретных директив. Для одного класса/стиля [class.x] и [style.x] легче и не требуют импортов.

angular
<div [ngClass]="{ active: isActive, disabled: !enabled }">Box</div>
<div [ngClass]="['card', 'shadow', themeClass]">Card</div>
<div [ngClass]="currentClass">String</div>

<div [ngStyle]="{ color: textColor, 'font-size.px': size }">Text</div>
<div [ngStyle]="styleObject">Styled</div>

<!-- import CommonModule (or NgClass/NgStyle) for these -->
<!-- prefer [class.x] and [style.x] for single value bindings -->

@switch (новый control flow)

@switch заменяет *ngSwitch (и директивы ngSwitchCase/ngSwitchDefault). Это чище — не нужна обёртка, не нужны импорты. Каждый @case рендерится только при совпадении значения с выражением @switch. @default — запасной вариант. Встроенный control flow доступен в v17+.

angular
@switch (status) {
  @case ('loading') {
    <spinner>Loading...</spinner>
  }
  @case ('error') {
    <p class="error">Something went wrong</p>
  }
  @case ('success') {
    <p>Done!</p>
  }
  @default {
    <p>Idle</p>
  }
}

Пользовательская атрибутная директива

Атрибутные директивы меняют внешний вид или поведение DOM-элементов. [скобки] в selector означают использование через атрибут. ElementRef даёт прямой доступ к DOM; HostListener привязывается к DOM-событиям. Внедряйте ElementRef<HTMLElement> для типобезопасности. При серверном рендеринге предпочитайте Renderer2 для манипуляций с DOM.

angular
import { Directive, ElementRef, Input, HostListener } from '@angular/core';

@Directive({
  selector: '[appHighlight]',
})
export class HighlightDirective {
  @Input('appHighlight') highlightColor = 'yellow';

  constructor(private el: ElementRef<HTMLElement>) {}

  @HostListener('mouseenter') onMouseEnter() {
    this.el.nativeElement.style.backgroundColor = this.highlightColor;
  }

  @HostListener('mouseleave') onMouseLeave() {
    this.el.nativeElement.style.backgroundColor = '';
  }
}

<!-- usage: <p appHighlight="lightblue">Hover me</p> -->

Внутреннее устройство структурных директив

Структурные директивы добавляют/удаляют DOM-узлы через TemplateRef (обёрнутый шаблон) и ViewContainerRef (куда вставлять). Звёздочка (*) — синтаксический сахар, оборачивающий элемент в <ng-template>. Новые блоки @if/@for/@switch заменяют большинство кастомных структурных директив, но этот паттерн всё ещё полезен в сложных случаях.

angular
import { Directive, TemplateRef, ViewContainerRef, Input } from '@angular/core';

@Directive({ selector: '[appUnless]' })
export class UnlessDirective {
  private hasView = false;

  @Input() set appUnless(condition: boolean) {
    if (!condition && !this.hasView) {
      this.vc.createEmbeddedView(this.tpl);
      this.hasView = true;
    } else if (condition && this.hasView) {
      this.vc.clear();
      this.hasView = false;
    }
  }

  constructor(private tpl: TemplateRef<unknown>, private vc: ViewContainerRef) {}
}

<!-- usage: <div *appUnless="hide">Shown when hide is false</div> -->
05

Пайпы

Встроенные пайпы

Пайпы преобразуют отображаемые в шаблоне значения. Частые встроенные: date, number, currency, percent, uppercase, lowercase, titlecase, slice, json, async. По умолчанию пайпы чистые — пересчитываются только при смене ссылки на вход. Строки формата следуют правилам Angular с учётом локали.

angular
<!-- date formatting -->
<p>{{ today | date }}</p>                          <!-- Sep 10, 2024 -->
<p>{{ today | date:'short' }}</p>
<p>{{ today | date:'yyyy-MM-dd HH:mm' }}</p>

<!-- number & currency -->
<p>{{ 3.14159 | number:'1.2-2' }}</p>               <!-- 3.14 -->
<p>{{ price | currency:'USD':'symbol':'1.2-2' }}</p>
<p>{{ ratio | percent }}</p>

<!-- text transforms -->
<p>{{ 'hello world' | uppercase }}</p>              <!-- HELLO WORLD -->
<p>{{ 'HELLO' | lowercase }}</p>
<p>{{ title | titlecase }}</p>
<p>{{ 'a/b/c' | slice:0:2 }}</p>

<!-- json (for debugging) -->
<pre>{{ obj | json }}</pre>

Цепочки пайпов и параметры

Пайпы объединяются слева направо, каждый получает выход предыдущего. Параметры разделяются двоеточиями и передаются позиционно. Применяйте их для чистых преобразований (форматирование, фильтрация), чтобы шаблоны оставались декларативными. Избегайте нечистых пайпов для чувствительных к производительности данных — вычисляйте в компоненте.

angular
<!-- chain: left to right, output of one feeds the next -->
<p>{{ '  hello  ' | trim | uppercase }}</p>         <!-- HELLO -->
<p>{{ birthday | date:'fullDate' | uppercase }}</p>
<p>{{ items | slice:0:3 | json }}</p>

<!-- parameters separated by colons -->
<p>{{ amount | number:'1.2-2':'en-US' }}</p>
<p>{{ meeting | date:'shortTime' }}</p>
<p>{{ list | slice:1:5 }}</p>

<!-- multiple parameters -->
<p>{{ value | myPipe:arg1:arg2:arg3 }}</p>

Пользовательский пайп

Пользовательские пайпы реализуют PipeTransform.transform(). Имя из @Pipe используется в шаблонах. Регистрируйте standalone-пайпы (v15+) в массиве imports компонента или объявляйте в NgModule. Чистые пайпы (по умолчанию) перезапускаются только при смене ссылки на вход — передавайте новые ссылки, чтобы вызвать обновление.

angular
import { Pipe, PipeTransform } from '@angular/core';

@Pipe({ name: 'truncate' })
export class TruncatePipe implements PipeTransform {
  transform(value: string, limit = 20, ellipsis = '...'): string {
    if (!value) return '';
    return value.length > limit
      ? value.slice(0, limit) + ellipsis
      : value;
  }
}

// register in a standalone component imports:
// imports: [TruncatePipe]

<!-- usage -->
<p>{{ longText | truncate:50 }}</p>
<p>{{ longText | truncate:10:'>>' }}</p>

Async-пайп

Пайп async подписывается на Observable или Promise, рендерит значение и автоматически отписывается при уничтожении — не нужен ручной subscribe/unsubscribe. В сочетании с *ngIf as или @for он аккуратно обрабатывает null во время загрузки. Пайп помечает компонент к проверке при поступлении нового значения, сочетаясь с OnPush.

angular
@Component({
  selector: 'app-user',
  template: `
    <div *ngIf="user$ | async as user">
      {{ user.name }}
    </div>
    <ul>
      @for (item of items$ | async; track item.id) {
        <li>{{ item.name }}</li>
      }
    </ul>
  `,
  imports: [AsyncPipe, NgIf],
})
export class UserComponent {
  user$ = this.http.get<User>('/api/user');
  items$ = this.http.get<Item[]>('/api/items');

  constructor(private http: HttpClient) {}
}

Чистые и нечистые пайпы

Чистые пайпы кешируют результат, пока не изменится ссылка на вход; мутация массивов или объектов их не запускает. Нечистые пайпы (pure: false) выполняются на каждом цикле обнаружения изменений — удобно для фильтрации мутируемых массивов, но затратно. Предпочитайте иммутабельные данные (создавайте новые массивы вместо мутации) и чистые пайпы ради производительности.

angular
// PURE (default): re-runs only when input reference changes
@Pipe({ name: 'filter' })
export class FilterPipe implements PipeTransform {
  transform(items: Item[], term: string): Item[] {
    return items.filter(i => i.name.includes(term));
  }
}
// Issue: mutating items.push() won't trigger re-evaluation.

// IMPURE: re-runs on every change detection cycle
@Pipe({ name: 'filter', pure: false })
export class ImpureFilterPipe implements PipeTransform { ... }
// ⚠️ Expensive! Use sparingly — affects performance.

Пайпы i18n и локали

Пайпы date, number, currency учитывают LOCALE_ID. Регистрируйте данные локали через registerLocaleData до bootstrap. Форматы валюты и чисел следуют активной локали. В многоязычных приложениях предоставляйте LOCALE_ID для каждого пользователя или используйте i18n-инструменты для перевода шаблонов. При отсутствии данных локали откат к en-US.

angular
// register locale data in app.config.ts
import { registerLocaleData } from '@angular/common';
import localeFr from '@angular/common/locales/fr';
registerLocaleData(localeFr);

// provide a default locale
providers: [{ provide: LOCALE_ID, useValue: 'fr-FR' }]

// usage - now locale-aware
<p>{{ price | currency:'EUR' }}</p>          <!-- 1 234,56 € -->
<p>{{ today | date:'fullDate' }}</p>          <!-- lundi 10 septembre 2024 -->
<p>{{ number | number:'1.2-2' }}</p>          <!-- 1 234,56 -->
<p>{{ amount | currency:'JPY' }}</p>          <!-- ¥1,235 -->
06

Сервисы и внедрение зависимостей

Базовый сервис

providedIn: 'root' создаёт синглтон, доступный во всём приложении, без регистрации в модуле. Сервис tree-shakeable — удаляется, если не используется. Используйте функцию inject() (v14+) вместо внедрения через конструктор — код чище и проще тестировать. Сервисы хранят общее состояние и бизнес-логику; компоненты остаются презентационными.

angular
import { Injectable } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class UserService {
  private users = ['Alice', 'Bob'];

  getUsers() { return this.users; }
  addUser(name: string) { this.users.push(name); }
}

// usage in a component
export class UserListComponent {
  // Angular injects the singleton instance
  constructor(private users: UserService) {}

  get users() { return this.usersService.getUsers(); }
  private usersService = inject(UserService);
}

Функция inject()

inject() — современная альтернатива внедрению через конструктор. Она работает в инициализаторах полей, делает код читабельнее и даёт лучший вывод типов TypeScript. Вызов должен происходить при конструировании (не в асинхронных колбэках позже). Используйте её последовательно — смешивать параметры конструктора и inject() можно, но inject() чище.

angular
import { Injectable, inject } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class AuthService {
  private http = inject(HttpClient);
  private router = inject(Router);

  login(creds: Credentials) {
    return this.http.post('/api/login', creds);
  }
}

// in a component
export class DashboardComponent {
  private auth = inject(AuthService);
  user = this.auth.currentUser;   // works in field initializers
}

Настройка провайдеров

Провайдеры настраиваются на любом уровне (root, модуль, компонент). useClass подменяет реализацию (удобно для моков). useValue передаёт константы. useExisting связывает один сервис с другим. useFactory создаёт экземпляры динамически. InjectionToken предназначен для значений, не являющихся классами: строк, конфигов и т. п.

angular
@Component({
  // ... provide at component level for instance-per-component
  providers: [
    UserService,                              // shorthand
    { provide: Logger, useClass: ConsoleLogger },
    { provide: API_URL, useValue: 'https://api.example.com' },
    { provide: Storage, useExisting: LocalStorageService },
    {
      provide: Config,
      useFactory: () => new Config(env.production)
    },
  ],
})
export class AdminComponent {}

// InjectionToken for non-class values
export const API_URL = new InjectionToken<string>('API_URL');

Иерархия инжекторов

Дерево DI в Angular повторяет дерево компонентов. providedIn: 'root' — один экземпляр на всё приложение. Провайдеры уровня компонента создают дочерние инжекторы — у каждого экземпляра свой. Это удобно для компонентов с состоянием, например редакторов. 'any' ограничивает ленивыми модулями. 'platform' редкий вариант для мультиприложений.

angular
// root injector (singleton app-wide)
@Injectable({ providedIn: 'root' })
export class AuthService {}

// component-level provider: new instance for this component and children
@Component({
  providers: [UserService],   // each AdminComponent gets its own UserService
})
export class AdminComponent {}

// 'any' creates a lazy singleton per lazy module
@Injectable({ providedIn: 'any' })
export class SharedService {}

// 'platform' shared across all Angular apps on the page
@Injectable({ providedIn: 'platform' })
export class GlobalConfig {}

Multi-провайдеры и токены

multi: true регистрирует несколько провайдеров под одним токеном, внедряемых как массив. Полезно для систем плагинов, интерсепторов, валидаторов и любых расширяемых коллекций. Порядок внедрения повторяет порядок регистрации. Совмещайте с InjectionToken, чтобы типизировать массив.

angular
// define a token for a list of plugins
export const PLUGIN = new InjectionToken<Plugin>('PLUGIN');

// provide multiple plugins
@Component({
  providers: [
    { provide: PLUGIN, useClass: AuthPlugin, multi: true },
    { provide: PLUGIN, useClass: AnalyticsPlugin, multi: true },
  ],
})
export class AppComponent {}

// inject all of them as an array
export class PluginManager {
  plugins = inject(PLUGIN);   // Plugin[]
}

Необязательные провайдеры и значения по умолчанию

@Optional() или inject(token, { optional: true }) возвращает null, если провайдер не найден, вместо исключения. Применяйте для некритичных зависимостей. Другие модификаторы: @SkipSelf() (не проверять текущий инжектор), @Self() (только текущий), @Host() (до хост-компонента). Эквиваленты inject() принимают флаги в объекте опций.

angular
import { Injectable, inject, Optional, Inject } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class Logger {
  constructor(@Optional() @Inject(CONFIG) private cfg?: Config) {
    // cfg is null if no provider exists — handle gracefully
  }
}

// or with inject()
export class Service {
  cfg = inject(CONFIG, { optional: true });   // Config | null
  baseUrl = inject(API_URL, { optional: true }) ?? '/api';
}

// skipSelf: look in parent injectors only
// self: only this component's injector
// host: limit to host component
07

Маршрутизация

Конфигурация маршрутов

Маршруты сопоставляют URL-пути с компонентами. loadComponent/loadChildren включают ленивую загрузку (меньше начальный бандл). :id — параметр маршрута. Дикий символ '**' перехватывает несовпавшие URL — ставьте его последним. provideRouter настраивает роутер в standalone-приложениях. Задайте title для заголовков вкладок; это строка или ResolveFn.

angular
// app.routes.ts (standalone)
import { Routes } from '@angular/router';

export const routes: Routes = [
  { path: '', component: HomeComponent, title: 'Home' },
  { path: 'about', loadComponent: () => import('./about/about.component')
      .then(m => m.AboutComponent) },
  { path: 'users/:id', component: UserDetailComponent },
  { path: 'admin', loadChildren: () => import('./admin/admin.routes')
      .then(m => m.ADMIN_ROUTES) },
  { path: '**', component: NotFoundComponent },   // wildcard
];

// app.config.ts
export const appConfig: ApplicationConfig = {
  providers: [provideRouter(routes)]
};

Router Outlet и ссылки

router-outlet отмечает место, где рендерятся маршрутизированные компоненты. routerLink создаёт навигационные ссылки (для параметров используйте форму массива). routerLinkActive добавляет класс при совпадении маршрута. Программная навигация — router.navigate() или routerLink. Именованные outlets позволяют создавать вторичные маршруты (например, модальное окно рядом с основным представлением).

angular
<!-- app.component.html -->
<nav>
  <a routerLink="/" routerLinkActive="active">Home</a>
  <a routerLink="/about" routerLinkActive="active">About</a>
  <a [routerLink]="['/users', userId]">My Profile</a>
</nav>

<router-outlet></router-outlet>

<!-- named outlet (secondary route) -->
<router-outlet name="popup"></router-outlet>

<!-- navigate programmatically -->
<button (click)="go()">Go</button>
// constructor(private router: Router) {}
// go() { this.router.navigate(['/users', 42]); }

Параметры маршрута и query-параметры

Используйте snapshot для одноразового чтения, когда компонент уничтожается и создаётся заново при каждой навигации. Используйте observable paramMap/queryParamMap, когда один экземпляр компонента обрабатывает разные параметры (например, переход с /users/1 на /users/2). Всегда отписывайтесь или используйте async-пайп, чтобы избежать утечек.

angular
// reading route params
export class UserDetailComponent {
  constructor(private route: ActivatedRoute) {
    // snapshot: one-time read (good for static links)
    const id = this.route.snapshot.paramMap.get('id');

    // observable: reacts to param changes (same component reused)
    this.route.paramMap.subscribe(params => {
      console.log(params.get('id'));
    });
  }
}

// query params: /search?q=angular&page=2
this.route.queryParamMap.subscribe(qp => {
  this.q = qp.get('q');
});

<!-- link with query params -->
<a [routerLink]="['/search']" [queryParams]="{ q: 'angular', page: 2 }">

Дочерние и вложенные маршруты

Дочерние маршруты рендерятся во вложенном router-outlet внутри родительского компонента. redirectTo с pathMatch: 'full' перенаправляет пустые дочерние пути. Этот паттерн строит раскладки master-detail (оболочка родителя, содержимое ребёнка). Каждый уровень вложенности требует собственного router-outlet в шаблоне родителя.

angular
export const routes: Routes = [
  {
    path: 'admin',
    component: AdminLayoutComponent,
    children: [
      { path: '', redirectTo: 'dashboard', pathMatch: 'full' },
      { path: 'dashboard', component: DashboardComponent },
      { path: 'users', component: AdminUsersComponent },
      { path: 'settings', component: SettingsComponent },
    ],
  },
];

<!-- AdminLayoutComponent template -->
<h2>Admin Panel</h2>
<nav>...</nav>
<router-outlet></router-outlet>   <!-- child routes render here -->

Ленивая загрузка

Ленивая загрузка разбивает приложение на чанки, загружаемые по требованию, уменьшая начальный бандл. loadChildren загружает файл маршрутов (default export Routes); loadComponent — один standalone-компонент. Строка в динамическом import() должна быть статическим путём, чтобы бандлер корректно разбил код. Используйте для функциональных областей, доступных после навигации.

angular
// main routes - load feature modules on demand
export const routes: Routes = [
  { path: '', component: HomeComponent },
  {
    path: 'admin',
    loadChildren: () => import('./admin/admin.routes').then(m => m.ADMIN_ROUTES),
  },
  {
    path: 'reports',
    loadComponent: () => import('./reports/reports.component')
      .then(m => m.ReportsComponent),
  },
];

// admin.routes.ts
export const ADMIN_ROUTES: Routes = [
  { path: '', component: AdminComponent },
  { path: 'users', component: AdminUsersComponent },
];

События роутера и навигация

События роутера (NavigationStart, NavigationEnd, GuardsCheckStart и др.) позволяют отслеживать жизненный цикл навигации. Всегда фильтруйте конкретные события и отписывайтесь. router.navigate принимает extras: queryParams, fragment, state (переходные данные, не попадающие в URL) и replaceUrl. state читается через router.getCurrentNavigation().extras.state.

angular
// subscribe to router events
export class AppComponent implements OnDestroy {
  private sub = this.router.events.pipe(
    filter((e): e is NavigationEnd => e instanceof NavigationEnd)
  ).subscribe(e => {
    console.log('Navigated to:', e.url);
    this.analytics.track(e.url);
  });

  constructor(private router: Router) {}
  ngOnDestroy() { this.sub.unsubscribe(); }
}

// navigation with extras
this.router.navigate(['/users'], {
  queryParams: { sort: 'name' },
  fragment: 'top',
  state: { from: 'login' },   // passed to next route, not in URL
});
08

Формы

Шаблонно-ориентированная форма

Шаблонно-ориентированные формы используют ngModel и ссылки в шаблоне. Требуется FormsModule. Состояние формы (валидность, touched, dirty) отслеживается директивами ngForm и ngModel. Подходит для простых форм. Валидация объявляется в шаблоне (required, minlength, pattern). Состояние контрола доступно через ссылки шаблона вида #e='ngModel'.

angular
import { FormsModule } from '@angular/forms';

@Component({
  selector: 'app-login',
  standalone: true,
  imports: [FormsModule],
  template: `
    <form #f="ngForm" (ngSubmit)="save(f.value)">
      <input name="email" [(ngModel)]="email" required email #e="ngModel" />
      <span *ngIf="e.invalid && e.touched">Email required</span>

      <input name="pwd" type="password" [(ngModel)]="pwd" required minlength="6" />
      <button [disabled]="f.invalid">Submit</button>
    </form>
  `,
})
export class LoginComponent {
  email = '';
  pwd = '';
  save(v: any) { console.log(v); }
}

Настройка реактивной формы

Реактивные формы определяют модель в классе компонента как экземпляры FormControl/FormGroup. Требуется ReactiveFormsModule. formControlName привязывает input к контролам. Модель формы — observable и тестируема без DOM. nonNullable: true предотвращает null при очистке поля. Предпочтительно для сложных форм.

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

@Component({
  selector: 'app-profile',
  imports: [ReactiveFormsModule],
  template: `
    <form [formGroup]="form" (ngSubmit)="save()">
      <input formControlName="name" />
      <input formControlName="email" />
      <button [disabled]="form.invalid">Save</button>
    </form>
    <p>Valid: {{ form.valid }}</p>
  `,
})
export class ProfileComponent {
  form = new FormGroup({
    name: new FormControl('', { nonNullable: true }),
    email: new FormControl('', { nonNullable: true }),
  });
  save() { console.log(this.form.value); }
}

FormBuilder и типизированные формы

FormBuilder сокращает шаблонный код. fb.group() выводит типы из значений по умолчанию. Вложенные группы моделируют вложенные данные. FormArray управляет динамическими списками контролов. С nonNullable контролы сохраняют объявленный тип вместо null. Используйте get() или controls для типобезопасного доступа. Типизированные формы (v14+) дают автодополнение и проверку типов для value.

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

export class CheckoutComponent {
  private fb = inject(FormBuilder);

  // typed form (v14+ nonNullable)
  form = this.fb.group({
    name: ['', { nonNullable: true }],
    address: this.fb.group({
      street: [''],
      city: [''],
      zip: [''],
    }),
    items: this.fb.array<CartItem>([]),
  });

  // type-safe access
  get items() { return this.form.controls.items; }
  addItem(item: CartItem) { this.items.push(this.fb.control(item)); }
}

Валидация формы

Validators.required, .minLength, .maxLength, .pattern, .email, .min, .max — встроенные. Несколько валидаторов применяются через массив. Кросс-полевая валидация живёт на FormGroup с функцией-валидатором, получающей всю группу. Проверяйте control.touched/dirty перед показом ошибок, чтобы не ругать пользователя при первом рендере. Используйте .hasError('key') для проверки конкретной ошибки.

angular
import { Validators } from '@angular/forms';

// built-in validators
const email = new FormControl('', [
  Validators.required,
  Validators.email,
  Validators.maxLength(100),
]);

const password = new FormControl('', [
  Validators.required,
  Validators.minLength(8),
  Validators.pattern(/[A-Z]/),
]);

// cross-field validation at group level
const form = this.fb.group({
  pwd: ['', Validators.required],
  confirm: ['', Validators.required],
}, { validators: matchPassword });   // custom group validator

// reading state in template
<!-- <span *ngIf="email.touched && email.hasError('required')">Required</span> -->

Пользовательский валидатор

Пользовательские валидаторы — функции, возвращающие ValidationErrors (объект-карту) или null при валидном значении. Асинхронные валидаторы возвращают Observable или Promise — применяйте их для серверных проверок вроде занятости имени пользователя. Всегда добавляйте debounce асинхронным валидаторам (через timer/switchMap), чтобы не атаковать сервер на каждое нажатие клавиши.

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

// function validator
export const matchPassword: ValidatorFn = (group: AbstractControl): ValidationErrors | null => {
  const pwd = group.get('pwd')?.value;
  const confirm = group.get('confirm')?.value;
  return pwd === confirm ? null : { mismatch: true };
};

// async validator (returns Observable/Promise)
export function uniqueUsername(http: HttpClient): AsyncValidatorFn {
  return (control: AbstractControl) => {
    return timer(500).pipe(
      switchMap(() => http.get(`/api/check/${control.value}`)),
      map(exists => exists ? { taken: true } : null),
    );
  };
}

Изменения значения и состояния формы

valueChanges и statusChanges — Observables, срабатывающие на каждый ввод. debounceTime предотвращает избыточную работу при быстром наборе. takeUntil с Subject — идиоматичный способ отписаться при уничтожении. patchValue обновляет часть значений формы; setValue требует все поля. Используйте { emitEvent: false }, чтобы обновлять молча, не триггеря valueChanges.

angular
export class FilterComponent implements OnDestroy {
  private destroy = new Subject<void>();
  form = this.fb.group({ q: [''], category: ['all'] });

  ngOnInit() {
    // react to entire form changes (debounced)
    this.form.valueChanges.pipe(
      debounceTime(300),
      takeUntil(this.destroy),
    ).subscribe(v => this.search(v));

    // react to a single control
    this.form.controls.q.valueChanges.subscribe(q => {
      console.log('q changed:', q);
    });
  }

  ngOnDestroy() { this.destroy.next(); }
}
09

HttpClient

Настройка и базовый GET

provideHttpClient() регистрирует клиент на всё приложение. Методы HttpClient возвращают холодные Observables — они выполняются только при подписке (используйте async-пайп в шаблонах или subscribe в сервисах). Ответы типизируются дженериками. Обрабатывайте ошибки централизованно или на каждый вызов. withFetch() (v18) включает современный бэкенд на fetch.

angular
// app.config.ts
import { provideHttpClient } from '@angular/common/http';

export const appConfig: ApplicationConfig = {
  providers: [provideHttpClient()],
};

// usage in a service
@Injectable({ providedIn: 'root' })
export class PostService {
  private http = inject(HttpClient);
  private api = 'https://jsonplaceholder.typicode.com/posts';

  getPosts() {
    return this.http.get<Post[]>(this.api);
  }
}

// in a component (use async pipe to auto-unsubscribe)
export class PostListComponent {
  posts$ = this.posts.getPosts();
  constructor(private posts: PostService) {}
}

POST / PUT / DELETE

post/put/patch возвращают Observables, которые передают ответ один раз и завершаются. Тело передаётся вторым аргументом. Дженерик уточняет тип ответа. URL может быть шаблонной строкой с параметрами. Всегда делайте subscribe — Observables холодные и без этого не выполнятся. Для одноразовых запросов используйте toPromise() (устарело) или firstValueFrom().

angular
export class PostService {
  private http = inject(HttpClient);

  create(post: Omit<Post, 'id'>) {
    return this.http.post<Post>('/api/posts', post);
  }

  update(id: number, patch: Partial<Post>) {
    return this.http.put<Post>(`/api/posts/${id}`, patch);
  }

  remove(id: number) {
    return this.http.delete<void>(`/api/posts/${id}`);
  }
}

// all return Observables — subscribe or use async pipe
// HTTP methods return a single value then complete

Query-параметры и заголовки

params принимает объект, HttpParams или массив — Angular кодирует их в query-строку. headers задаёт заголовки запроса. observe: 'response' возвращает полный HttpResponse (статус, заголовки, тело) вместо одного тела. observe: 'events' с reportProgress передаёт события прогресса для загрузки/скачивания файлов.

angular
export class SearchService {
  private http = inject(HttpClient);

  search(term: string, page = 1) {
    return this.http.get<Result[]>('/api/search', {
      params: { q: term, page, sort: 'desc' },
      headers: { 'X-Api-Key': 'secret' },
      observe: 'response',   // get full HttpResponse
      responseType: 'json',
    });
  }

  // observe: 'events' streams upload/download progress
  upload(file: File) {
    return this.http.post('/api/upload', file, {
      reportProgress: true,
      observe: 'events',
    });
  }
}

Интерсепторы

Функциональные интерсепторы (v15+) — обычные функции, объединяемые через withInterceptors(). Они выполняются по порядку для каждого запроса и идеально подходят для auth-токенов, логирования, повторов или кеширования. clone() создаёт изменённую копию запроса (запросы иммутабельны). Функция next(req) возвращает поток ответов — здесь применимы операторы pipe вроде retry и catchError.

angular
// functional interceptor (v15+)
export const authInterceptor: HttpInterceptorFn = (req, next) => {
  const token = localStorage.getItem('token');
  const authReq = token
    ? req.clone({ setHeaders: { Authorization: `Bearer ${token}` } })
    : req;
  return next(authReq);
};

// register in app.config.ts
providers: [provideHttpClient(withInterceptors([authInterceptor]))]

// error/logging interceptor
export const loggingInterceptor: HttpInterceptorFn = (req, next) => {
  console.log('Request:', req.url);
  return next(req).pipe(tap({
    error: e => console.error('Failed:', req.url, e),
  }));
};

Обработка ошибок

Используйте операторы RxJS для устойчивости HTTP: retry повторяет подписку при ошибке, timeout прерывает медленные запросы, catchError преобразует ошибки в запасные значения или пробрасывает дальше. Обрабатывайте ошибки и на стороне потребителя — неперехваченные ошибки Observable останавливают поток. Подписывайтесь с колбэками next/error/complete для полного контроля жизненного цикла.

angular
export class PostService {
  getPost(id: number) {
    return this.http.get<Post>(`/api/posts/${id}`).pipe(
      retry(2),                              // retry on failure
      timeout(5000),                         // abort after 5s
      catchError(err => {
        if (err.status === 404) return of(null);   // graceful fallback
        return throwError(() => new Error('Network error'));
      }),
    );
  }
}

// component-side
this.posts.getPost(1).subscribe({
  next: p => this.post = p,
  error: e => this.error = e.message,
  complete: () => this.loading = false,
});

Типизированные ответы и withFetch

Дженерики типизируют тело ответа, но не валидируют в runtime — для безопасности используйте runtime-валидатор вроде zod. observe: 'response' открывает status, headers и body. withFetch() (v18) использует Fetch API вместо XHR, включая стриминг и улучшенный серверный рендеринг. withXsrfConfiguration добавляет автоматическую обработку CSRF-токена.

angular
// typed generic — response is typed, runtime NOT validated
this.http.get<User[]>('/api/users');

// full HttpResponse observation
this.http.get<User>('/api/users/1', { observe: 'response' })
  .subscribe(res => {
    console.log(res.status);   // 200
    console.log(res.headers.get('X-Total-Count'));
    console.log(res.body);     // User
  });

// opt into fetch() backend (v18+, recommended)
// provideHttpClient(withFetch())

// with XSRF protection enabled
// provideHttpClient(withXsrfConfiguration({ cookieName: 'XSRF-TOKEN' }))
10

Observables и RxJS

Базовый Observable

Observables ленивы — источник выполняется только при подписке. Они могут передать ноль или больше значений, затем завершиться или ошибиться. Колбэк subscribe получает next, error, complete. Всегда отписывайтесь от долгоживущих подписок (или используйте async-пайп / takeUntilDestroyed). of() передаёт значения синхронно; from() разворачивает массивы и промисы.

angular
import { Observable } from 'rxjs';

const obs = new Observable<number>(subscriber => {
  subscriber.next(1);
  subscriber.next(2);
  setTimeout(() => {
    subscriber.next(3);
    subscriber.complete();
  }, 1000);
});

const sub = obs.subscribe({
  next: v => console.log(v),
  error: e => console.error(e),
  complete: () => console.log('done'),
});

// cleanup
sub.unsubscribe();

// use of(...) for synchronous values
of(1, 2, 3).subscribe(v => console.log(v));
// from(iterable) for arrays/async iterables
from([1, 2, 3]).subscribe(console.log);

Частые операторы

Операторы преобразуют потоки. map/filter работают как методы массива. debounceTime ждёт паузу (идеален для полей поиска). distinctUntilChanged пропускает повторяющиеся подряд значения. switchMap отменяет предыдущий внутренний Observable при новом значении — идеально для поиска по мере ввода. Операторы pipe применяются слева направо.

angular
import { of, from, interval } from 'rxjs';
import { map, filter, switchMap, debounceTime, distinctUntilChanged } from 'rxjs/operators';

of(1, 2, 3, 4).pipe(
  map(x => x * 10),                          // 10, 20, 30, 40
  filter(x => x > 15),                       // 20, 30, 40
).subscribe(console.log);

// search input with debounce
input$.pipe(
  debounceTime(300),
  distinctUntilChanged(),
  switchMap(term => http.get(`/api/search?q=${term}`)),
).subscribe(results => this.results = results);

Комбинирование потоков

combineLatest срабатывает при передаче любого источника (после того как все передали хотя бы раз) — удобно для производного состояния представления. forkJoin ждёт завершения всех источников и возвращает последнее значение каждого — используйте для параллельных HTTP-запросов. merge перемешивает передачи. zip сопоставляет по индексу. race выбирает первый сработавший Observable и игнорирует остальные.

angular
import { combineLatest, forkJoin, merge, race, zip } from 'rxjs';

// combineLatest: emits when ANY source emits, after all have emitted
combineLatest([user$, settings$]).subscribe(([u, s]) => ...);

// forkJoin: waits for all to complete, emits last values (like Promise.all)
forkJoin({ user: user$, posts: posts$ }).subscribe(r => ...);

// merge: emits values from all sources as they come
merge(clicks$, keys$).subscribe(e => ...);

// zip: pairs emissions by index
zip(range(1, 3), ['a', 'b', 'c']).subscribe(([n, letter]) => ...);

// race: takes the first to emit, ignores the rest
race(primary$, fallback$).subscribe(v => ...);

Subjects (мультикаст)

Subjects являются одновременно Observable и Observer — вызывайте .next() для передачи значений. Subject: без начального значения, поздние подписчики пропускают ранние передачи. BehaviorSubject: требует начального значения, новые подписчики сразу получают текущее значение (для состояния). ReplaySubject: буферизует последние N значений для новых подписчиков (для воспроизведения событий).

angular
import { Subject, BehaviorSubject, ReplaySubject } from 'rxjs';

// Subject: emits to current subscribers only
const click$ = new Subject<MouseEvent>();
click$.subscribe(x => console.log('A:', x));
click$.next({} as MouseEvent);   // A: logs it

// BehaviorSubject: keeps last value, new subs get it immediately
const count$ = new BehaviorSubject(0);
count$.subscribe(v => console.log(v));   // logs 0 immediately
count$.next(1);                          // logs 1 to subscribers

// ReplaySubject: replays last N values to new subscribers
const recent$ = new ReplaySubject<string>(2);
recent$.next('a'); recent$.next('b'); recent$.next('c');
recent$.subscribe(v => console.log(v));  // logs 'b', then 'c'

takeUntil и очистка

takeUntil(unsubscribe$) автоматически завершает подписку, когда нотификатор срабатывает — стандартный паттерн против утечек в компонентах. takeUntilDestroyed() (v16+) использует DestroyRef Angular для автоотписки без шаблонного кода OnDestroy. Он должен вызываться в контексте внедрения (конструктор или инициализатор поля) или принимать DestroyRef явно.

angular
import { Subject, takeUntil, takeUntilDestroyed } from 'rxjs';

export class DemoComponent implements OnDestroy {
  private destroy$ = new Subject<void>();

  ngOnInit() {
    this.svc.stream$.pipe(
      takeUntil(this.destroy$),
    ).subscribe(data => this.data = data);
  }

  ngOnDestroy() { this.destroy$.next(); this.destroy$.complete(); }
}

// v16+: takeUntilDestroyed (uses DestroyRef, no boilerplate)
export class DemoComponent {
  data: any;
  constructor() {
    inject(SomeService).stream$.pipe(
      takeUntilDestroyed(),
    ).subscribe(d => this.data = d);
  }
}

switchMap vs mergeMap vs concatMap

Эти операторы выравнивания различаются обработкой пересекающихся внутренних Observables. switchMap отменяет (поиск по мере ввода). mergeMap выполняет параллельно (загрузить многое). concatMap ставит в очередь (сохранить порядок). exhaustMap отбрасывает (защита от двойной отправки). Неправильный выбор вызывает состояния гонки — подбирайте оператор по семантике отмены конкретного сценария.

angular
import { from, interval } from 'rxjs';
import { switchMap, mergeMap, concatMap, exhaustMap } from 'rxjs/operators';

// switchMap: cancels the previous inner stream on new value
input$.pipe(switchMap(term => search(term)));
// Best for: typeahead search (discard stale results)

// mergeMap: runs all inner streams in parallel
ids$.pipe(mergeMap(id => fetchDetail(id)));
// Best for: parallel requests, order doesn't matter

// concatMap: queues inner streams, runs one at a time
queue$.pipe(concatMap(task => runTask(task)));
// Best for: ordered sequential operations

// exhaustMap: ignores new values while inner stream is active
save$.pipe(exhaustMap(() => saveForm()));
// Best for: prevent double-submit (ignore clicks while saving)
11

Хуки жизненного цикла

Порядок хуков

Хуки срабатывают в строгом порядке. ngOnChanges срабатывает при изменении @Input (и изначально). ngOnInit срабатывает один раз после первого ngOnChanges. ngDoCheck выполняется на каждом цикле обнаружения изменений. Хуки After* сигнализируют, что контент/представление готовы для запросов к DOM. ngOnDestroy — место для очистки: отписки, освобождение ресурсов, отмена таймеров.

angular
export class LifecycleComponent implements
    OnChanges, OnInit, DoCheck, AfterContentInit,
    AfterContentChecked, AfterViewInit, AfterViewChecked, OnDestroy {

  ngOnChanges()    { console.log('1. input changes'); }
  ngOnInit()       { console.log('2. component init (once)'); }
  ngDoCheck()      { console.log('3. custom change detection'); }
  ngAfterContentInit()      { console.log('4. projected content ready'); }
  ngAfterContentChecked()   { console.log('5. projected content checked'); }
  ngAfterViewInit()         { console.log('6. view (template) ready'); }
  ngAfterViewChecked()      { console.log('7. view checked'); }
  ngOnDestroy()    { console.log('8. cleanup before destroy'); }
}

ngOnInit и ngOnDestroy

ngOnInit выполняется один раз после установки входов — правильное место для затратной инициализации (запросы, подписки), так как конструктор должен оставаться дешёвым. ngOnDestroy — единственный хук, вызываемый при уничтожении компонента: не пропускайте здесь очистку, иначе получите утечки подписок, таймеров и обработчиков событий. Конструктор — только для DI; логику размещайте в ngOnInit.

angular
export class ChartComponent implements OnInit, OnDestroy {
  private timer?: ReturnType<typeof setInterval>;

  ngOnInit() {
    // good for: data fetching, initialization, subscriptions
    this.timer = setInterval(() => this.refresh(), 5000);
    this.loadInitialData();
  }

  ngOnDestroy() {
    // cleanup: clear timers, unsubscribe, release resources
    if (this.timer) clearInterval(this.timer);
    // also: this.sub.unsubscribe();
  }

  private refresh() { /* ... */ }
  private loadInitialData() { /* ... */ }
}

ngOnChanges (SimpleChange)

ngOnChanges срабатывает при каждом изменении ссылки @Input и получает карту SimpleChanges: каждая запись содержит previousValue, currentValue, firstChange и isFirstChange(). Он НЕ срабатывает при мутации свойств объекта — только при смене ссылки. Для глубоких изменений используйте ngOnChanges с сеттером или ngDoCheck с IterableDiffers.

angular
export class PaginationComponent implements OnChanges {
  @Input() page = 1;
  @Input() total = 0;

  ngOnChanges(changes: SimpleChanges) {
    if (changes['page'] && !changes['page'].firstChange) {
      // react only when page actually changed (not on init)
      console.log('page:', changes['page'].previousValue, '->', changes['page'].currentValue);
      this.fetchPage(this.page);
    }
  }

  private fetchPage(p: number) { /* ... */ }
}

ngAfterViewInit и ViewChild

Запросы ViewChild/ContentChild разрешаются ПОСЛЕ соответствующих init-хуков. ngAfterViewInit — для элементов собственного шаблона компонента; ngAfterContentInit — для спроецированного содержимого через <ng-content>. Обращение к этим ссылкам в ngOnInit вернёт undefined. Утверждение ! сообщает компилятору, что значение установится после инициализации — безопасно пользоваться только в хуках After*.

angular
export class CanvasComponent implements AfterViewInit {
  @ViewChild('canvas') canvasRef!: ElementRef<HTMLCanvasElement>;

  // ❌ canvasRef is undefined in ngOnInit
  ngOnInit() { /* this.canvasRef is undefined here */ }

  // ✅ available after view init
  ngAfterViewInit() {
    const canvas = this.canvasRef.nativeElement;
    const ctx = canvas.getContext('2d');
    ctx?.fillText('Hello', 10, 50);
  }
}

// template: <canvas #canvas></canvas>

ngDoCheck (собственное обнаружение)

ngDoCheck выполняется на каждом цикле обнаружения изменений — держите его лёгким. Используйте IterableDiffers/KeyValueDiffers, чтобы отслеживать мутации массивов/объектов, которые пропускает ngOnChanges (ведь ссылки не меняются). Это запасной выход для отслеживания внутренних мутаций. Избегайте тяжёлой логики — она выполняется часто и вызывает проблемы производительности.

angular
export class ListComponent implements DoCheck {
  @Input() items: Item[] = [];
  private differ: IterableDiffer<Item>;

  constructor(differs: IterableDiffers) {
    this.differ = differs.find(items).create<Item>((i) => i.id);
  }

  ngDoCheck() {
    const changes = this.differ.diff(this.items);
    if (changes) {
      changes.forEachAddedItem(r => console.log('Added:', r.item));
      changes.forEachRemovedItem(r => console.log('Removed:', r.item));
    }
  }
}

Хуки контента и представления

Хуки контента (AfterContentInit/Checked) срабатывают для спроецированного содержимого через <ng-content>. Хуки представления (AfterViewInit/Checked) — для собственного шаблона компонента. Хуки контента срабатывают ДО хуков представления, потому что контент инициализируется раньше завершения представления. @ContentChild запрашивает спроецированные элементы; @ViewChild — элементы собственного шаблона.

angular
export class CardComponent implements
    AfterContentInit, AfterViewInit, AfterContentChecked, AfterViewChecked {

  @ContentChild('header') headerTpl?: TemplateRef<unknown>;
  @ViewChild('body') bodyEl?: ElementRef<HTMLElement>;

  // projected content (<ng-content>) is ready
  ngAfterContentInit() {
    console.log('content ready:', this.headerTpl);
  }

  // own template view is ready
  ngAfterViewInit() {
    console.log('view ready:', this.bodyEl?.nativeElement);
  }

  // ContentChecked/ViewChecked run every CD cycle after init — beware perf
}
12

Проекция контента

Базовый ng-content

<ng-content> — заполнитель, куда проецируется содержимое, переданное родителем. Считайте это Angular-аналогом <slot>. Без select сюда попадает весь спроецированный контент. Спроецированный контент компилируется в контексте родителя — привязки вида {{ }} разрешаются против родительского компонента, а не CardComponent.

angular
// card.component.ts
@Component({
  selector: 'app-card',
  template: `
    <div class="card">
      <ng-content></ng-content>
    </div>
  `,
  styles: ['.card { border: 1px solid #ccc; padding: 16px; }'],
})
export class CardComponent {}

<!-- usage: anything inside projects into <ng-content> -->
<app-card>
  <h3>Title</h3>
  <p>Body content here.</p>
</app-card>

Многослотовая проекция

Атрибут select у ng-content выбирает конкретный спроецированный контент: по элементу ('header'), атрибуту ('[header]'), классу ('.active') или их комбинациям ('div.foo[bar]'). Неподпавший контент попадает в ng-content без select. Спроецированный контент сохраняет стили и контекст родителя — меняется только его место в DOM.

angular
@Component({
  selector: 'app-layout',
  template: `
    <header><ng-content select="[header]"></ng-content></header>
    <main><ng-content></ng-content></main>
    <footer><ng-content select="footer"></ng-content></footer>
  `,
})
export class LayoutComponent {}

<!-- usage: select matches attributes, elements, classes -->
<app-layout>
  <nav header>Top nav</nav>
  <p>Main body</p>
  <footer>Bottom</footer>
</app-layout>

Условная проекция (ng-template)

Для условной или повторяемой проекции ng-template с ngTemplateOutlet даёт полный контроль. ContentChildren запрашивает спроецированные директивы. ngTemplateOutlet рендерит TemplateRef в выбранном месте — удобно для вкладок, аккордеонов или условных слотов. Этот паттерн отделяет объявление контента от места и времени рендеринга.

angular
@Component({
  selector: 'app-tabs',
  template: `
    <div class="tabs">
      @for (t of tabs; track t) {
        <button (click)="active = t">{{ t.title }}</button>
      }
    </div>
    @for (t of tabs; track t) {
      @if (t === active) {
        <ng-container [ngTemplateOutlet]="t.template" />
      }
    }
  `,
})
export class TabsComponent {
  @ContentChildren(TabDirective) tabs!: QueryList<TabDirective>;
  active: any;
}

ContentChild и ContentChildren

@ContentChild / @ContentChildren запрашивают спроецированный контент (в отличие от ViewChild для собственного шаблона). ContentChildren возвращает QueryList, обновляющуюся при изменении контента. Разрешайте в ngAfterContentInit. Опция { descendants: true } (по умолчанию) обходит весь спроецированный контент. Используйте { read: ... }, чтобы запросить конкретный тип (ElementRef, TemplateRef и т. д.).

angular
@Directive({ selector: 'tab' })
export class TabDirective {
  @Input() title = '';
  @Input() active = false;
  @ContentChild(TemplateRef) template!: TemplateRef<unknown>;
}

@Component({
  selector: 'app-tabset',
  template: `
    @for (tab of tabs; track tab) {
      <button (click)="select(tab)">{{ tab.title }}</button>
    }
    <ng-container *ngTemplateOutlet="activeTab?.template" />
  `,
})
export class TabsetComponent implements AfterContentInit {
  @ContentChildren(TabDirective) tabs!: QueryList<TabDirective>;
  activeTab?: TabDirective;

  ngAfterContentInit() {
    this.activeTab = this.tabs.find(t => t.active) ?? this.tabs.first;
  }
}

ngTemplateOutlet с контекстом

ngTemplateOutlet рендерит TemplateRef с необязательным контекстом. let-x привязывается к context.$implicit (значение по умолчанию); let-y='key' — к context.key. Так *ngFor и ngTemplateOutlet передают переменные цикла. Используйте этот паттерн для переиспользуемых шаблонов списков/сеток/элементов, которые родитель может настроить, а компонент управляет логикой итерации.

angular
@Component({
  selector: 'app-list',
  template: `
    @for (item of items; track item.id) {
      <ng-container *ngTemplateOutlet="itemTpl; context: { $implicit: item, i: $index }" />
    }
    <ng-template #itemTpl let-item let-i="i">
      <li>{{ i }}: {{ item.name }}</li>
    </ng-template>
  `,
})
export class ListComponent {
  items = [{ id: 1, name: 'A' }, { id: 2, name: 'B' }];
}

Паттерны select у ng-content

select принимает CSS-подобные селекторы: классы (.x), атрибуты ([x]), элементы (header) или списки через запятую ('a, b'). Контент, не подошедший ни под один селектор, попадает в ng-content без select. Если запасного слота нет, неподошедший контент отбрасывается. Селекторы сопоставляются с собственными атрибутами спроецированных элементов, а не с их внутренним устройством.

angular
@Component({
  selector: 'app-modal',
  template: `
    <div class="modal">
      <ng-content select=".modal-header"></ng-content>
      <ng-content select="[body]"></ng-content>
      <ng-content select="app-modal-footer, footer"></ng-content>
      <!-- fallback for unmatched content -->
      <ng-content></ng-content>
    </div>
  `,
})

<!-- matches by class, attribute, element, or selector list -->
<app-modal>
  <div class="modal-header">Title</div>
  <section body>Body text</section>
  <app-modal-footer>OK</app-modal-footer>
  <p>This falls into the unselect'd slot.</p>
</app-modal>
13

Гварды маршрутов

CanActivate (функциональный)

Функциональные гварды (v14.2+) возвращают true/false/UrlTree или Observable/Promise этих значений. Возвращённый UrlTree перенаправляет на этот маршрут. inject() работает, потому что гварды выполняются в контексте внедрения. CanActivate предотвращает переход к маршруту. Регистрируйте гварды на маршруте в массиве canActivate. Они запускаются при каждой навигации на этот маршрут.

angular
import { inject } from '@angular/core';
import { CanActivateFn, Router } from '@angular/router';

export const authGuard: CanActivateFn = (route, state) => {
  const auth = inject(AuthService);
  const router = inject(Router);

  if (auth.isLoggedIn) return true;

  // redirect to login, preserving the attempted URL
  return router.createUrlTree(['/login'], {
    queryParams: { returnUrl: state.url },
  });
};

// register in routes
{ path: 'dashboard', component: DashboardComponent, canActivate: [authGuard] }

CanActivateChild

CanActivateChild выполняется перед каждым дочерним маршрутом родителя — чище, чем повторять canActivate на каждом ребёнке. Используйте для общей защиты функциональной области. Возвращает те же типы значений, что CanActivate. Чтобы защитить и сам родительский маршрут, добавьте canActivate также на него.

angular
export const adminGuard: CanActivateChildFn = (route, state) => {
  const auth = inject(AuthService);

  if (!auth.isAdmin) {
    return inject(Router).parseUrl('/forbidden');
  }
  return true;
};

// applies to all children of this route
{
  path: 'admin',
  canActivateChild: [adminGuard],
  children: [
    { path: 'users', component: AdminUsersComponent },
    { path: 'settings', component: AdminSettingsComponent },
  ],
}

CanDeactivate (несохранённые изменения)

CanDeactivate выполняется перед уходом с маршрута — идеально для предупреждения о несохранённых изменениях формы. Гвард получает экземпляр компонента и вызывает его метод. Верните false, чтобы отменить навигацию, true — чтобы продолжить. Для асинхронного подтверждения (модальное окно) верните Observable или Promise. Компонент должен реализовать контракт, который ожидает гвард.

angular
import { CanDeactivateFn } from '@angular/router';
import { inject } from '@angular/core';

export interface CanComponentDeactivate {
  canDeactivate: () => boolean | Observable<boolean>;
}

export const unsavedGuard: CanDeactivateFn<CanComponentDeactivate> = (component) => {
  return component?.canDeactivate() ?? true;
};

// component
export class EditComponent implements CanComponentDeactivate {
  canDeactivate() {
    if (this.form.dirty) return confirm('Discard changes?');
    return true;
  }
}

// route: { path: 'edit/:id', canDeactivate: [unsavedGuard] }

CanMatch (условная загрузка)

CanMatch (v14.1+) выполняется до скачивания чанка ленивого маршрута — эффективнее CanActivate для ограничения платных функций. Если он вернёт false, маршрут полностью пропускается (шанс получают другие подходящие маршруты). CanActivate сначала загрузил бы чанк, а затем отказал. Используйте CanMatch, чтобы не скачивать код, недоступный пользователю.

angular
import { CanMatchFn } from '@angular/router';

export const paidFeatureGuard: CanMatchFn = (route, segments) => {
  const auth = inject(AuthService);
  // runs BEFORE the lazy chunk is even loaded
  if (auth.hasProPlan) return true;

  return inject(Router).createUrlTree(['/upgrade']);
};

// route configuration
{
  path: 'premium',
  canMatch: [paidFeatureGuard],
  loadComponent: () => import('./premium/premium.component'),
}

Resolve (предзагрузка данных)

Resolve выполняется до активации маршрута и задерживает навигацию до поступления данных. Разрешённые данные попадают в route.snapshot.data. Полезно, чтобы компонент имел данные на момент рендера (без мигания пустого состояния). Обрабатывайте ошибки внутри резолвера — возвращённый EMPTY отменяет навигацию. Для неблокирующей загрузки запрашивайте данные в ngOnInit.

angular
import { ResolveFn } from '@angular/router';
import { inject } from '@angular/core';

export const userResolver: ResolveFn<User> = (route) => {
  const id = route.paramMap.get('id')!;
  return inject(UserService).getUser(+id).pipe(
    catchError(() => {
      inject(Router).navigate(['/users']);
      return EMPTY;
    }),
  );
};

// route
{ path: 'users/:id', resolve: { user: userResolver }, component: UserComponent }

// component reads pre-fetched data
export class UserComponent {
  user = this.route.snapshot.data['user'] as User;
  constructor(private route: ActivatedRoute) {}
}

Композиция и порядок гвардов

Несколько гвардов выполняются в порядке массива; первый отказ отменяет навигацию. canMatch выполняется до загрузки ленивых чанков; canActivate — после. canDeactivate — при уходе. Все гварды могут быть синхронными (возвращают boolean) или асинхронными (Observable/Promise). Держите их быстрыми — они блокируют UI. Тяжёлые серверные проверки стоит кешировать или debounce-ить.

angular
// multiple guards run in declaration order, all must pass
{
  path: 'admin',
  canActivate: [authGuard, roleGuard],
  canMatch: [paidFeatureGuard],
  canDeactivate: [unsavedGuard],
  loadChildren: () => import('./admin/admin.routes'),
}

// guard returning Observable (async check)
export const roleGuard: CanActivateFn = () => {
  return inject(AuthService).hasRole('admin').pipe(
    map(ok => ok || inject(Router).parseUrl('/forbidden')),
  );
};

// ordering: canMatch → resolve → canActivate → canActivateChild
14

Резолверы

Базовый резолвер (ResolveFn)

ResolveFn — функциональный API резолверов. Он выполняется до завершения навигации, и возвращённое значение попадает в route.data под назначенным вами ключом. Компонент может прочитать его синхронно из snapshot.data — состояние загрузки не нужно. Подписывайтесь на route.data для реактивных обновлений при переходах между маршрутами одного компонента.

angular
import { ResolveFn } from '@angular/router';
import { inject } from '@angular/core';

export const postResolver: ResolveFn<Post> = (route, state) => {
  const id = Number(route.paramMap.get('id'));
  return inject(PostService).getPost(id);
};

// route
{
  path: 'posts/:id',
  resolve: { post: postResolver },
  component: PostDetailComponent,
}

// reading the resolved data
export class PostDetailComponent {
  post = this.route.snapshot.data['post'] as Post;
  constructor(private route: ActivatedRoute) {}

  // reactive: re-fetch when :id changes (same component reused)
  ngOnInit() {
    this.route.data.subscribe(d => this.post = d['post']);
  }
}

Несколько резолверов

Несколько резолверов выполняются параллельно — все должны завершиться до активации маршрута. Каждый ключ в resolve становится ключом в route.data. Если один падает, навигация отменяется. Для независимых данных это эффективно. Если данные зависят друг от друга, вложите их или объедините в одном резолвере. Взвешивайте резолвер против загрузки в ngOnInit.

angular
{
  path: 'dashboard',
  component: DashboardComponent,
  resolve: {
    user: userResolver,
    stats: statsResolver,
    notifications: notifResolver,
  },
}

// component
export class DashboardComponent {
  constructor(private route: ActivatedRoute) {}
  ngOnInit() {
    const { user, stats, notifications } = this.route.snapshot.data;
    // all three resolved before component loads
  }
}

Обработка ошибок резолвера

Обрабатывайте ошибки резолвера явно — неперехваченные ошибки молча отменяют навигацию. EMPTY завершает поток без передачи значения, отменяя навигацию. Возврат null позволяет компоненту корректно обработать недостающие данные. Для 404 перенаправляйте на маршрут not-found. Всегда логируйте или показывайте ошибки — тихие сбои сложно диагностировать.

angular
export const userResolver: ResolveFn<User | null> = (route) => {
  const id = route.paramMap.get('id')!;
  const router = inject(Router);
  const service = inject(UserService);

  return service.getUser(+id).pipe(
    catchError(err => {
      if (err.status === 404) {
        // redirect to a 'not found' page, cancel navigation
        router.navigate(['/404']);
        return EMPTY;
      }
      // re-throw other errors
      return throwError(() => err);
    }),
  );
};

Резолвер против загрузки в ngOnInit

Резолверы блокируют навигацию до прихода данных — чистый UX, но ощущается медленнее. Загрузка в ngOnInit не блокирует, но требует состояний загрузки в компоненте. Современные рекомендации Angular склоняются к неблокирующему подходу: загружайте в компоненте со скелетоном загрузки — субъективная скорость выше. Используйте резолверы, только когда компонент действительно не может отрендериться без данных.

angular
// Approach A: Resolver (blocks navigation until data arrives)
// ✅ Component renders with data — no flicker
// ❌ Slower navigation feel, blocks route transition
{
  path: 'user/:id',
  resolve: { user: userResolver },
  component: UserComponent,
}

// Approach B: Fetch in ngOnInit (non-blocking)
// ✅ Snappy navigation, show loading skeleton
// ❌ Component must handle null/loading state
export class UserComponent implements OnInit {
  user?: User;
  loading = true;
  ngOnInit() {
    this.route.params.subscribe(p => {
      this.loading = true;
      this.svc.getUser(+p['id']).subscribe(u => {
        this.user = u;
        this.loading = false;
      });
    });
  }
}

Резолвер с query-параметрами и signals

Резолверы могут читать и paramMap, и queryParamMap из маршрута. Когда один компонент обрабатывает разные параметры, подписывайтесь на route.data реактивно вместо snapshot. С signals обновляйте сигнал из подписки на данные. Комбинируйте резолверы с signals для чистого реактивного потока данных. Избегайте тяжёлых резолверов — они блокируют навигацию.

angular
// read query params inside a resolver
export const searchResolver: ResolveFn<SearchResult[]> = (route) => {
  const q = route.queryParamMap.get('q') ?? '';
  const page = Number(route.queryParamMap.get('page') ?? 1);
  return inject(SearchService).search(q, page);
};

// resolver feeding a signal-based component
export class SearchComponent {
  private route = inject(ActivatedRoute);
  results = signal<SearchResult[]>([]);

  constructor() {
    this.route.data.subscribe(d => this.results.set(d['results']));
  }
}
15

Анимации

Настройка и базовая анимация

provideAnimations() регистрирует модуль анимаций. trigger() объявляет именованную анимацию; transition() описывает переход между состояниями. :enter и :leave — встроенные псевдосостояния для элементов, добавляемых/удаляемых через *ngIf или @if. Применяется через @triggerName в шаблоне. С control flow v17+ анимации работают и с @if/@for.

angular
// app.config.ts
import { provideAnimations } from '@angular/platform-browser/animations';
export const appConfig: ApplicationConfig = {
  providers: [provideAnimations()],
};

// component
@Component({
  selector: 'app-fade',
  animations: [
    trigger('fadeIn', [
      transition(':enter', [
        style({ opacity: 0 }),
        animate('300ms ease-in', style({ opacity: 1 })),
      ]),
      transition(':leave', [
        animate('300ms ease-out', style({ opacity: 0 })),
      ]),
    ]),
  ],
  template: `<div *ngIf="show" @fadeIn>Hello</div>`,
})

Состояния и переходы

state() задаёт именованные стили в покое. transition('a => b') анимирует переход из состояния a в b; '<=>' — двунаправленный. Привяжите триггер к выражению, возвращающему имя состояния. Стили состояния применяются мгновенно (без анимации); transition анимирует между ними. Используйте 'void' для элементов, которых ещё нет в DOM, и '*' как wildcard.

angular
@Component({
  selector: 'app-toggle',
  animations: [
    trigger('openClose', [
      state('open', style({ height: '*', opacity: 1 })),
      state('closed', style({ height: '0', opacity: 0 })),
      transition('open => closed', animate('200ms ease-out')),
      transition('closed => open', animate('300ms ease-in')),
      // bidirectional shortcut: 'open <=> closed'
    ]),
  ],
  template: `
    <button (click)="isOpen = !isOpen">Toggle</button>
    <div [@openClose]="isOpen ? 'open' : 'closed'">Panel</div>
  `,
})
export class ToggleComponent { isOpen = false; }

Keyframes и параллельные анимации

keyframes() задаёт промежуточные шаги с offset (от 0 до 1) для точного контроля — как CSS @keyframes. group() выполняет анимации параллельно; sequence() — одну за другой. С их помощью собираются сложные эффекты появления/исчезновения. Держите анимации короткими (200-400 мс) и учитывайте prefers-reduced-motion для доступности.

angular
trigger('wiggle', [
  transition('* => *', [
    animate('600ms ease-in-out', keyframes([
      style({ transform: 'translateX(0)', offset: 0 }),
      style({ transform: 'translateX(-10px)', offset: 0.25 }),
      style({ transform: 'translateX(10px)', offset: 0.75 }),
      style({ transform: 'translateX(0)', offset: 1 }),
    ])),
  ]),
]),

// parallel/group animations
transition(':enter', [
  group([
    animate('300ms', style({ opacity: 1 })),
    animate('300ms', style({ transform: 'translateY(0)' })),
  ]),
]),

Анимированный список (@for)

Применяйте анимации :enter/:leave к элементам @for — они срабатывают при добавлении или удалении элементов. track обеспечивает корректное отождествление элементов между изменениями, поэтому анимации запускаются при реальном добавлении/удалении (а не при пересортировке). Без правильного track анимации списков дёргаются. Для анимаций переупорядочивания используйте query() и animateChild().

angular
@Component({
  selector: 'app-list',
  animations: [
    trigger('itemAnim', [
      transition(':enter', [
        style({ height: 0, opacity: 0 }),
        animate('200ms', style({ height: '*', opacity: 1 })),
      ]),
      transition(':leave', [
        animate('200ms', style({ height: 0, opacity: 0 })),
      ]),
    ]),
  ],
  template: `
    @for (item of items; track item.id) {
      <div @itemAnim>{{ item.name }}</div>
    }
  `,
})
export class AnimListComponent { items = [...]; }

Анимации роутера

Привяжите триггер анимации к состоянию активации router-outlet. query(':enter'/:leave) нацелен на входящий/исходящий маршрутизированный компонент. { optional: true } избегает ошибок, когда одной стороны нет (при начальной загрузке нет :leave). position: absolute укладывает старый и новый компоненты друг на друга во время перехода. Анимации маршрутов дают переходы в стиле нативных приложений.

angular
@Component({
  selector: 'app-root',
  animations: [
    trigger('routeAnim', [
      transition('* => *', [
        query(':enter', [
          style({ opacity: 0, position: 'absolute', width: '100%' }),
          animate('300ms', style({ opacity: 1 })),
        ], { optional: true }),
        query(':leave', [
          animate('300ms', style({ opacity: 0 })),
        ], { optional: true }),
      ]),
    ]),
  ],
  template: `
    <div [@routeAnim]="o.isActivated ? o.activatedRoute : ''">
      <router-outlet #o="outlet"></router-outlet>
    </div>
  `,
})

Reduced motion и CSS-анимации

Всегда учитывайте prefers-reduced-motion для доступности — у некоторых пользователей анимации вызывают укачивание. Анимации Angular добавляют ~50 КБ к бандлу; для простых затуханий хватит чистых CSS-анимаций. Используйте Angular-анимации, когда нужны переходы с состоянием (автоматы состояний), координация родитель-потомок или анимации маршрутов. CSS легче для эффектов hover/затухания.

angular
// respect prefers-reduced-motion
@Component({
  selector: 'app-safe-anim',
  animations: [
    trigger('fade', [
      transition(':enter', [
        style({ opacity: 0 }),
        animate('300ms', style({ opacity: 1 })),
      ]),
    ]),
  ],
  // or just use CSS — Angular animations add bundle weight
  template: `<div class="fade-in" @fade>Content</div>`,
  styles: [`
    @media (prefers-reduced-motion: reduce) {
      .fade-in { animation: none !important; transition: none !important; }
    }
  `],
})
16

Тестирование

Настройка теста компонента

TestBed конфигурирует тестовый модуль. Для standalone-компонентов импортируйте их напрямую (объявления в TestBed.configureTestingModule не нужны). createComponent возвращает ComponentFixture: .componentInstance — экземпляр класса, .nativeElement — DOM, .detectChanges() запускает обнаружение изменений. beforeEach с async/await обрабатывает compileComponents.

angular
import { ComponentFixture, TestBed } from '@angular/core/testing';
import { MyComponent } from './my.component';

describe('MyComponent', () => {
  let fixture: ComponentFixture<MyComponent>;
  let component: MyComponent;

  beforeEach(async () => {
    await TestBed.configureTestingModule({
      imports: [MyComponent],   // standalone components are imported
    }).compileComponents();

    fixture = TestBed.createComponent(MyComponent);
    component = fixture.componentInstance;
    fixture.detectChanges();   // runs initial change detection
  });

  it('should create', () => {
    expect(component).toBeTruthy();
  });
});

Тестирование с мок-сервисами

Предоставляйте мок-реализации сервисов, чтобы изолировать тестируемый компонент. jasmine.createSpy() позволяет управлять возвращаемыми значениями и проверять вызовы. useValue — для моков-объектов, useClass — для фейков на основе классов. Подменяйте HttpClient на HttpTestingController для HTTP-тестов. Моки делают тесты быстрыми и детерминированными — без реальных сетевых вызовов.

angular
describe('UserComponent', () => {
  let mockUserService = {
    getUsers: jasmine.createSpy().and.returnValue(of([...])),
    addUser: jasmine.createSpy().and.returnValue(of({})),
  };

  beforeEach(async () => {
    await TestBed.configureTestingModule({
      imports: [UserComponent],
      providers: [
        { provide: UserService, useValue: mockUserService },
      ],
    }).compileComponents();
  });

  it('loads users on init', () => {
    const fixture = TestBed.createComponent(UserComponent);
    fixture.detectChanges();
    expect(mockUserService.getUsers).toHaveBeenCalled();
    expect(fixture.componentInstance.users.length).toBe(2);
  });
});

Тестирование HTTP

HttpTestingController перехватывает вызовы HttpClient в тестах — реальной сети нет. expectOne проверяет, что запрос был сделан, и возвращает его; flush() имитирует ответ сервера. verify() убеждается, что необработанных запросов не осталось. Тестируйте и успех, и ошибку: flush со статус-кодом (например, { status: 500, statusText: 'Server Error' }) имитирует сбой.

angular
import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
import { provideHttpClient } from '@angular/common/http';

describe('PostService', () => {
  let service: PostService;
  let httpMock: HttpTestingController;

  beforeEach(() => {
    TestBed.configureTestingModule({
      providers: [
        PostService,
        provideHttpClient(),
        provideHttpClientTesting(),
      ],
    });
    service = TestBed.inject(PostService);
    httpMock = TestBed.inject(HttpTestingController);
  });

  it('fetches posts', () => {
    service.getPosts().subscribe(posts => expect(posts.length).toBe(2));

    const req = httpMock.expectOne('/api/posts');
    expect(req.request.method).toBe('GET');
    req.flush([{ id: 1 }, { id: 2 }]);   // simulate response
    httpMock.verify();                    // no outstanding requests
  });
});

Тестирование шаблона и взаимодействий

fixture.nativeElement даёт прямой доступ к DOM для проверок. detectChanges() синхронизирует привязки шаблона после изменения свойств. spyOn позволяет проверять вызовы методов. Для запросов внутри компонента debugElement.query(By.css()) типобезопасен. Триггерьте события нативными методами DOM (click()) или DebugElement.triggerEventHandler для кастомных событий.

angular
it('renders the title', () => {
  const fixture = TestBed.createComponent(MyComponent);
  fixture.componentInstance.title = 'Hello';
  fixture.detectChanges();
  const el: HTMLElement = fixture.nativeElement;
  expect(el.querySelector('h1')?.textContent).toContain('Hello');
});

it('calls save on button click', () => {
  const fixture = TestBed.createComponent(MyComponent);
  const spy = spyOn(fixture.componentInstance, 'save');
  const button = fixture.nativeElement.querySelector('button');
  button.click();
  expect(spy).toHaveBeenCalled();
});

// By.css for debug element queries (faster than nativeElement)
const debugEl = fixture.debugElement.query(By.css('.submit'));

Тестирование Signals

Сигналы — это функции: вызывайте их (со скобками), чтобы прочитать значения в тестах. set() обновляет записываемые сигналы напрямую, исключая непрямые манипуляции. detectChanges() синхронизирует шаблоны, зависящие от сигналов. Для computed/effect вызовите detectChanges или TestBed.flushEffects(), чтобы зависимые эффекты выполнились. Сигналы делают тесты более синхронными и предсказуемыми.

angular
describe('CounterComponent', () => {
  it('increments count', () => {
    const fixture = TestBed.createComponent(CounterComponent);
    const comp = fixture.componentInstance;

    expect(comp.count()).toBe(0);
    comp.increment();
    expect(comp.count()).toBe(1);

    // force signal effects to run in tests
    fixture.detectChanges();
  });

  it('renders count in template', () => {
    const fixture = TestBed.createComponent(CounterComponent);
    fixture.componentInstance.count.set(5);
    fixture.detectChanges();   // syncs signal to template
    expect(fixture.nativeElement.textContent).toContain('5');
  });
});

E2E с Cypress / Playwright

E2E-тесты прогоняют всё приложение через реальный браузер. Используйте атрибуты data-cy как селекторы — они стабильны и не зависят от CSS-классов. Cypress работает в браузере; Playwright — во множестве браузеров. Используйте ng e2e или настройте Cypress/Playwright вручную. E2E ловят интеграционные проблемы, упущенные юнит-тестами, но медленнее — держите набор сфокусированным.

angular
// cypress test (cypress/e2e/login.cy.ts)
describe('Login flow', () => {
  beforeEach(() => cy.visit('/login'));

  it('logs in with valid credentials', () => {
    cy.get('[data-cy=email]').type('[email protected]');
    cy.get('[data-cy=password]').type('secret123');
    cy.get('[data-cy=submit]').click();

    cy.url().should('include', '/dashboard');
    cy.contains('Welcome, User');
  });
});

// run with: npx cypress open  (interactive)
//           npx cypress run   (headless CI)
17

PWA

Добавление поддержки PWA

ng add @angular/pwa создаёт всё необходимое: регистрацию service worker, веб-манифест и иконки. Service worker работает только в продакшен-сборке (ng build --configuration production) — в dev он отключён, чтобы избежать неожиданного кеширования. registrationStrategy управляет моментом регистрации SW; registerWhenStable ждёт стабилизации приложения.

angular
# add @angular/service-worker
ng add @angular/pwa --project my-app

# this generates:
# - ngsw-config.json (service worker config)
# - manifest.webmanifest
# - icons in src/assets/icons/
# - registers service worker in app.config.ts

# app.config.ts (auto-updated)
export const appConfig: ApplicationConfig = {
  providers: [
    provideRouter(routes),
    provideServiceWorker('ngsw-worker.js', {
      enabled: environment.production,
      registrationStrategy: 'registerWhenStable:30000',
    }),
  ],
};

Конфигурация Service Worker (ngsw-config.json)

assetGroups кешируют оболочку приложения (prefetch) и статические ресурсы (lazy). dataGroups кешируют ответы API со стратегиями freshness/performance и TTL. prefetch скачивает заранее; lazy — по требованию. freshness сначала пробует сеть, затем кеш (для свежих данных); performance использует кеш в первую очередь (для квазистатичных данных).

angular
{
  "$schema": "./node_modules/@angular/service-worker/config/schema.json",
  "index": "/index.html",
  "assetGroups": [
    {
      "name": "app",
      "installMode": "prefetch",
      "updateMode": "prefetch",
      "resources": {
        "files": ["/favicon.ico", "/index.html", "/manifest.webmanifest", "/*.css", "/*.js"]
      }
    },
    {
      "name": "assets",
      "installMode": "lazy",
      "updateMode": "prefetch",
      "resources": { "files": ["/assets/**", "/*.(svg|png|jpg|jpeg|webp|woff2)"] }
    }
  ],
  "dataGroups": [
    {
      "name": "api",
      "urls": ["https://api.example.com/**"],
      "cacheConfig": {
        "maxSize": 100, "maxAge": "1d", "timeout": "10s", "strategy": "freshness"
      }
    }
  ]
}

Обработка обновлений

SwUpdate уведомляет о доступности новой версии. VERSION_READY означает, что новый бандл скачан и готов к активации. activateUpdate() переключает на новую версию; перезагрузите страницу, чтобы её загрузить. Для критичных обновлений активируйте сразу. Для некритичных — предложите пользователю. Подписывайтесь на versionUpdates, чтобы обработать VERSION_DETECTED, VERSION_READY и NO_NEW_VERSION_DETECTED.

angular
import { SwUpdate } from '@angular/service-worker';
import { inject } from '@angular/core';

export class UpdatePromptComponent {
  private updates = inject(SwUpdate);
  updateAvailable = false;

  constructor() {
    this.updates.versionUpdates.subscribe(evt => {
      if (evt.type === 'VERSION_READY') {
        this.updateAvailable = true;
      }
    });
  }

  applyUpdate() {
    this.updates.activateUpdate().then(() => document.location.reload());
  }
}

Офлайн-поддержка и кеширование

SwPush включает веб-push-уведомления через service worker. requestSubscription запрашивает разрешение у пользователя и возвращает объект подписки для отправки на ваш сервер. SW получает push-события даже при закрытой вкладке. VAPID-ключи аутентифицируют ваш сервер. Сочетайте с Notification API для показа сообщений; обрабатывайте клики для навигации внутри приложения.

angular
import { SwPush } from '@angular/service-worker';

export class NotificationComponent {
  private swPush = inject(SwPush);

  subscribeToPush() {
    this.swPush.requestSubscription({
      serverPublicKey: this.VAPID_PUBLIC,
    }).then(sub => this.sendToServer(sub))
      .catch(err => console.error('Push denied', err));
  }

  // check if SW is enabled
  ngOnInit() {
    if (!this.swPush.isEnabled) {
      console.warn('Push notifications not supported');
    }
  }
}

Манифест приложения

Веб-манифест делает приложение устанавливаемым (Add to Home Screen). name/short_name отображаются на домашнем экране; theme_color окрашивает интерфейс браузера; display: standalone убирает оболочку браузера для ощущения приложения. Предоставьте иконки нескольких размеров (192, 512) плюс maskable-иконку для Android. Проверяйте установку через PWA-аудит Lighthouse.

angular
<!-- index.html (added by ng add @angular/pwa) -->
<link rel="manifest" href="manifest.webmanifest">
<meta name="theme-color" content="#1976d2">
<meta name="apple-mobile-web-app-capable" content="yes">
<meta name="apple-mobile-web-app-status-bar-style" content="black">
<link rel="apple-touch-icon" href="assets/icons/icon-152x152.png">

// manifest.webmanifest
{
  "name": "My App",
  "short_name": "MyApp",
  "theme_color": "#1976d2",
  "background_color": "#fafafa",
  "display": "standalone",
  "scope": "/",
  "start_url": "/",
  "icons": [
    { "src": "assets/icons/icon-192x192.png", "sizes": "192x192", "type": "image/png" },
    { "src": "assets/icons/icon-512x512.png", "sizes": "512x512", "type": "image/png" }
  ]
}

Устанавливаемость и Lighthouse

beforeinstallprompt срабатывает в Chrome, когда приложение устанавливаемо, и позволяет отложить нативное приглашение. Сохраните событие и вызовите prompt() по жесту пользователя (клик по кнопке). iOS Safari не генерирует это событие — установка через меню «Поделиться». Запускайте PWA-аудит Lighthouse для проверки устанавливаемости. PWA работает офлайн, только когда service worker кеширует оболочку приложения.

angular
// detect install prompt (Chrome)
let deferredPrompt: any;
window.addEventListener('beforeinstallprompt', (e) => {
  e.preventDefault();
  deferredPrompt = e;
  this.canInstall = true;   // show "Install App" button
});

// user-triggered install (must be from user gesture)
async installApp() {
  if (!deferredPrompt) return;
  deferredPrompt.prompt();
  const { outcome } = await deferredPrompt.userChoice;
  console.log('Install:', outcome);
  deferredPrompt = null;
}

// Lighthouse PWA checklist:
// ✅ served over HTTPS
// ✅ registers a service worker
// ✅ has a web manifest with icons
// ✅ start_url loads offline
18

Standalone-компоненты

Bootstrap standalone

bootstrapApplication запускает standalone-приложение — NgModule не нужен. Корневой AppComponent должен быть standalone. app.config.ts централизует провайдеры (роутер, http, анимации, конфигурация zone). Это поведение по умолчанию с v17. Каждая функция provideX() подключает подсистему. Намного чище, чем AppModule с его провайдерами.

angular
// main.ts
import { bootstrapApplication } from '@angular/platform-browser';
import { appConfig } from './app/app.config';
import { AppComponent } from './app/app.component';

bootstrapApplication(AppComponent, appConfig)
  .catch(err => console.error(err));

// app.config.ts
import { ApplicationConfig, provideZoneChangeDetection } from '@angular/core';
import { provideRouter } from '@angular/router';
import { provideHttpClient } from '@angular/common/http';
import { routes } from './app.routes';

export const appConfig: ApplicationConfig = {
  providers: [
    provideZoneChangeDetection({ eventCoalescing: true }),
    provideRouter(routes),
    provideHttpClient(),
  ],
};

Импорты standalone-компонента

standalone: true помечает компонент как самодостаточный. Массив imports перечисляет всё, что нужно шаблону: модули, компоненты, директивы, пайпы. С control flow v17+ (@if/@for) CommonModule для них не требуется. Импортируйте только используемое для лучшего tree-shaking. Standalone-компоненты можно использовать и в NgModule через exports.

angular
@Component({
  selector: 'app-user-list',
  standalone: true,
  imports: [
    CommonModule,          // *ngIf, *ngFor, pipes (or use built-in @if/@for)
    FormsModule,           // ngModel
    UserCardComponent,     // another standalone component
    HighlightDirective,    // standalone directive
    TruncatePipe,          // standalone pipe
  ],
  template: `
    <input [(ngModel)]="filter" />
    @for (u of users; track u.id) {
      <app-user-card [user]="u" appHighlight>{{ u.name | truncate:20 }}</app-user-card>
    }
  `,
})
export class UserListComponent { ... }

Standalone-маршруты и ленивая загрузка

loadComponent лениво загружает один standalone-компонент — минимально возможный чанк. loadChildren лениво загружает файл маршрутов (default export Routes). Оба используют динамический import() со статическим путём, чтобы бандлер разбил код. Это полностью заменяет feature-модули. Каждый ленивый маршрут получает собственный JS-файл, загружаемый при первой навигации.

angular
export const routes: Routes = [
  { path: '', loadComponent: () => import('./home/home.component')
      .then(m => m.HomeComponent) },
  {
    path: 'admin',
    loadComponent: () => import('./admin/admin.component')
      .then(m => m.AdminComponent),
    canMatch: [authGuard],
  },
  {
    path: 'reports',
    loadChildren: () => import('./reports/reports.routes')
      .then(m => m.REPORTS_ROUTES),
  },
];

Директивы и пайпы как standalone

Директивы и пайпы тоже могут быть standalone (v15+). Добавьте standalone: true и импортируйте их в любой нуждающийся компонент. Это избавляет от объявления в общем модуле. Для обратной совместимости standalone-директивы/пайпы можно добавлять в exports NgModule и использовать в модульных компонентах.

angular
@Directive({
  selector: '[appHighlight]',
  standalone: true,
})
export class HighlightDirective { ... }

@Pipe({
  name: 'truncate',
  standalone: true,
})
export class TruncatePipe implements PipeTransform { ... }

// use directly in a standalone component's imports
@Component({
  imports: [HighlightDirective, TruncatePipe],
  template: `<p appHighlight>{{ text | truncate:10 }}</p>`,
})

Миграция с NgModule

Схематика автоматизирует миграцию: делает все объявления standalone, переносит импорты NgModule в массивы imports каждого компонента и удаляет устаревшие модули. Запускайте постепенно — миграция может быть частичной. После миграции можно удалить AppRoutingModule, AppModule и перейти на bootstrapApplication. Результат — более лёгкое приложение с лучшим tree-shaking.

angular
# automatic migration (v15.2+)
ng generate @angular/core:standalone

# options:
# 1. Convert all components/directives/pipes to standalone
# 2. Remove unnecessary NgModule classes
# 3. Bootstrap the app using bootstrapApplication

// before: declared in a module
@NgModule({
  declarations: [OldComponent],
  imports: [CommonModule],
  exports: [OldComponent],
})
export class OldModule {}

// after: standalone component
@Component({
  standalone: true,
  imports: [CommonModule],
  // ...
})
export class OldComponent {}

Внедрение в standalone-провайдерах

Standalone-приложения настраивают провайдеры в app.config.ts вместо AppModule. APP_INITIALIZER выполняет подготовку до bootstrap. Провайдеры уровня компонента ограничены его поддеревом. Для сервисов по-прежнему предпочтителен providedIn: 'root' — он tree-shakeable. Массивы providers используйте для значений, не являющихся сервисами (токены, конфиги, моки).

angular
// app.config.ts — global providers
export const appConfig: ApplicationConfig = {
  providers: [
    { provide: API_URL, useValue: 'https://api.example.com' },
    { provide: ErrorHandler, useClass: GlobalErrorHandler },
    { provide: APP_INITIALIZER, multi: true, useFactory: () => initApp },
  ],
};

// component-level providers (scoped to this component and children)
@Component({
  providers: [
    { provide: UserService, useClass: MockUserService },
  ],
})
export class AdminComponent {}

// tree-shakable service
@Injectable({ providedIn: 'root' })  // preferred over providers array
export class AuthService {}
19

Signals

Создание сигналов

signal() создаёт реактивное значение. Чтение вызовом: count(). Обновление через set() (замена) или update() (вычисление из предыдущего). Сигналы синхронны и избегают накладных расходов Observables для простого состояния. В шаблонах их можно вызывать со скобками () — в v17.2+ они также разворачиваются автоматически в некоторых контекстах. Сигналы интегрируются с обнаружением изменений OnPush.

angular
import { signal, computed, effect } from '@angular/core';

export class CounterComponent {
  // writable signal with initial value
  count = signal(0);
  user = signal<User | null>(null);

  // reading: call the signal as a function
  current = this.count();    // 0

  // writing
  increment() { this.count.update(v => v + 1); }
  setFive() { this.count.set(5); }

  // in templates, signals are called automatically in v17.2+
  // {{ count }} or {{ count() }} both work in templates
}

Вычисляемые сигналы

computed() создаёт производный сигнал только для чтения, который сам отслеживает зависимости и кеширует значение. Он пересчитывается, только если зависимость изменилась И его снова прочитали — ленивое вычисление. Вычисляемые сигналы могут зависеть от других вычисляемых, образуя граф. В отличие от методов, они кешируют результат. Это заменяет многие сценарии RxJS combineLatest.

angular
export class CartComponent {
  items = signal<Item[]>([]);
  taxRate = signal(0.08);

  // derived state — recomputes only when items or taxRate change
  subtotal = computed(() =>
    this.items().reduce((sum, i) => sum + i.price * i.qty, 0)
  );
  tax = computed(() => Math.round(this.subtotal() * this.taxRate() * 100) / 100);
  total = computed(() => this.subtotal() + this.tax());

  // computed signals are readonly and cached
  // they recompute lazily only when read AND a dependency changed
}

Эффекты (побочные эффекты)

effect() выполняет побочный эффект при изменении зависимостей-сигналов. Применяйте для логирования, синхронизации с localStorage, загрузки данных или работы с DOM. Эффекты выполняются после обнаружения изменений. Не записывайте в сигналы, которые читаются в том же эффекте — это создаст бесконечный цикл. onCleanup регистрирует логику завершения для следующего запуска. Эффекты создаются в контексте внедрения.

angular
export class SearchComponent {
  query = signal('');
  results = signal<Result[]>([]);

  constructor() {
    // effect runs when its signal dependencies change
    effect(() => {
      const q = this.query();
      // ⚠️ avoid setting signals read in this effect (causes loops)
      this.search(q).then(r => this.results.set(r));
    });
  }

  // effect with cleanup
  private log = effect((onCleanup) => {
    const id = setInterval(() => console.log(this.count()), 1000);
    onCleanup(() => clearInterval(id));
  });
}

Сигналы в шаблонах (OnPush)

Сигналы бесшовно интегрируются с OnPush — Angular точно знает, какие представления зависят от сигнала, и помечает только их к проверке при изменении. Ручной markForCheck() не нужен. В шаблонах вызывайте сигналы со скобками () для чтения. OnPush + signals — самая эффективная схема обнаружения изменений, часто позволяющая полностью отказаться от zone.js (zoneless-режим).

angular
@Component({
  selector: 'app-todo',
  // signals work great with OnPush — automatic efficiency
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: `
    <input (input)="text.set($any($event.target).value)" />
    <p>You typed: {{ text() }}</p>
    <p>Length: {{ length() }}</p>
    <button (click)="clear()">Clear</button>
  `,
})
export class TodoComponent {
  text = signal('');
  length = computed(() => this.text().length);
  clear() { this.text.set(''); }
}

Signal-входы и запросы

input()/input.required() создают signal-входы только для чтения. output() создаёт типизированные выходы. model() создаёт двусторонне привязываемые signal-входы (с автоматически генерируемым выходом xChange). viewChild()/contentChild() возвращают сигналы, разрешающиеся после инициализации представления — читайте их вызовом (). Эти современные API заменяют декораторы @Input/@Output/@ViewChild реактивными сигналами.

angular
import { input, output, viewChild, contentChild, model } from '@angular/core';

export class EditComponent {
  // signal input (readonly, v17.1+)
  id = input<number>(0);
  requiredName = input.required<string>();

  // signal output (v17.3+)
  saved = output<User>();

  // two-way signal (v17.2+)
  value = model<number>(0);   // creates input + output named valueChange

  // signal queries
  inputEl = viewChild<ElementRef>('input');      // in own template
  header = contentChild<TemplateRef>('header');  // projected content

  focus() { this.inputEl()?.nativeElement.focus(); }
}

Signals и RxJS-интероп

toSignal преобразует Observable в сигнал (подписывается один раз, отписывается при уничтожении). toObservable делает обратное. Используйте интероп, чтобы смешивать сигналы (для синхронного состояния) с RxJS (для сложных асинхронных потоков вроде поиска с debounce). takeUntilDestroyed автоматически отписывается через DestroyRef. initialValue предотвращает чтение undefined до первой передачи. Требуется контекст внедрения.

angular
import { toSignal, toObservable, takeUntilDestroyed } from '@angular/core/rxjs-interop';

export class SearchComponent {
  private http = inject(HttpClient);

  // Observable → Signal (one-way)
  results = toSignal(this.http.get<Result[]>('/api/results'), {
    initialValue: [] as Result[],
  });

  // Signal → Observable (for RxJS operators)
  private query$ = toObservable(this.query);

  // combine the best of both worlds
  filtered = toSignal(
    this.query$.pipe(
      debounceTime(300),
      switchMap(q => this.http.get(`/api/search?q=${q}`)),
      takeUntilDestroyed(),
    ),
    { initialValue: [] as Result[] },
  );
}
20

NgModules и архитектура

Структура NgModule

NgModules организуют приложение в связные блоки. declarations перечисляет то, чем владеет модуль. imports подключает экспорты других модулей. exports открывает объявления для импортирующих. Только корневой модуль задаёт bootstrap. Современный Angular предпочитает standalone-компоненты (без NgModule), но NgModule-приложения ещё существуют. Знайте оба подхода — старые кодовые базы и некоторые библиотеки используют модули.

angular
@NgModule({
  declarations: [                  // components, directives, pipes owned by this module
    AppComponent,
    UserListComponent,
    HighlightDirective,
    TruncatePipe,
  ],
  imports: [                       // other modules whose exports this module needs
    BrowserModule,
    FormsModule,
    HttpClientModule,
    AppRoutingModule,
  ],
  exports: [                       // what's visible to modules that import this module
    UserListComponent,
    TruncatePipe,
  ],
  providers: [],                   // services (use providedIn: 'root' instead)
  bootstrap: [AppComponent],       // only in the root module
})
export class AppModule {}

Feature и Shared модули

SharedModule объединяет общие UI-компоненты/директивы/пайпы для повторного использования в фичах — реэкспортируйте CommonModule и FormsModule, чтобы импортирующим не приходилось делать это самим. Feature-модули инкапсулируют функциональную область; forChild() позволяет одному модулю настраиваться по-разному при каждом импорте (например, маршрутизация). В standalone-приложениях предпочитайте отдельные standalone-компоненты общим модулям.

angular
// shared.module.ts — reusable UI bits
@NgModule({
  imports: [CommonModule, FormsModule],
  declarations: [ButtonComponent, CardComponent, HighlightDirective],
  exports: [ButtonComponent, CardComponent, HighlightDirective, FormsModule],
})
export class SharedModule {}

// feature module (lazy-loaded)
@NgModule({
  declarations: [AdminComponent, AdminUsersComponent],
  imports: [CommonModule, RouterModule, SharedModule],
  exports: [AdminComponent],
})
export class AdminModule {
  static forChild(): ModuleWithProviders<AdminModule> {
    return { ngModule: AdminModule, providers: [AdminService] };
  }
}

Core Module и синглтон-сервисы

CoreModule содержит общие для приложения синглтоны (сервисы, интерсепторы, обработчики ошибок) и импортируется один раз в AppModule. Проверка в конструкторе предотвращает случайный повторный импорт (он создал бы дубликаты сервисов). В standalone-приложениях эти провайдеры переезжают в app.config.ts. Паттерн CoreModule устарел, но встречается в кодовых базах до v14.

angular
// core.module.ts — app-wide singletons, imported once in AppModule
@NgModule({
  providers: [
    AuthService,
    { provide: HTTP_INTERCEPTORS, useClass: AuthInterceptor, multi: true },
    { provide: ErrorHandler, useClass: GlobalErrorHandler },
  ],
})
export class CoreModule {
  // guard against importing twice
  constructor(@Optional() @SkipSelf() parent?: CoreModule) {
    if (parent) throw new Error('CoreModule already loaded');
  }
}

Паттерн forRoot vs forChild

forRoot настраивает корневой экземпляр (вызывается один раз в AppModule); forChild регистрирует дочерние маршруты (вызывается в feature-модулях). Этот паттерн используется RouterModule и библиотечными модулями, которым нужна конфигурация. Современный Angular заменяет его функциями provideX() в app.config.ts. Паттерн всё ещё встречается в сторонних библиотеках — понимайте его для интеграции.

angular
// classic RouterModule pattern
@NgModule({ imports: [CommonModule], exports: [RouterModule] })
export class RouterModule {
  static forRoot(routes: Routes): ModuleWithProviders<RouterModule> {
    return {
      ngModule: RouterModule,
      providers: [provideRouter(routes)],
    };
  }
  static forChild(routes: Routes): ModuleWithProviders<RouterModule> {
    return { ngModule: RouterModule, providers: [provideRoutes(routes)] };
  }
}

// AppModule imports: RouterModule.forRoot(ROUTES)
// FeatureModule imports: RouterModule.forChild(FEATURE_ROUTES)

// modern equivalent: provideRouter(routes) in app.config.ts

Entry Components и динамические компоненты

entryComponents (устарело) перечисляло компоненты, создаваемые динамически (диалоги, модальные окна). Современный Angular использует ViewContainerRef.createComponent() или NgComponentOutlet — регистрация не нужна. Это бесшовно работает со standalone-компонентами. createComponent возвращает ComponentRef с .instance и .destroy(). Вызывайте destroy() для очистки, чтобы избежать утечек.

angular
// older API: entryComponents for dynamically created components
@NgModule({
  entryComponents: [DialogComponent, ModalComponent],
})
export class AppModule {}

// modern: ViewContainerRef.createComponent (no entryComponents needed)
export class DialogService {
  constructor(private vcr: ViewContainerRef) {}

  open() {
    const ref = this.vcr.createComponent(DialogComponent);
    ref.instance.title = 'Hello';
    ref.instance.close.subscribe(() => ref.destroy());
    return ref;
  }
}

// even simpler: NgComponentOutlet in template
<ng-container *ngComponentOutlet="dialogComponent; inputs: { title: 'Hi' }" />

Лениво загружаемые модули

Лениво загружаемые модули создают отдельный JS-чанк, загружаемый при навигации. Динамический import() должен быть статической строкой, чтобы бандлер разбил код. У ленивых модулей свой корневой инжектор — сервисы с providedIn внутри ленивого модуля не являются синглтонами для всего приложения. Современные standalone-приложения используют loadComponent/loadChildren с файлами маршрутов — проще и гранулярнее.

angular
// classic lazy module (pre-standalone)
const routes: Routes = [
  {
    path: 'admin',
    loadChildren: () => import('./admin/admin.module').then(m => m.AdminModule),
  },
];

// admin-routing.module.ts
const routes: Routes = [
  { path: '', component: AdminComponent },
  { path: 'users', component: AdminUsersComponent },
];

@NgModule({
  imports: [RouterModule.forChild(routes)],
  exports: [RouterModule],
})
export class AdminRoutingModule {}

// admin.module.ts
@NgModule({
  declarations: [AdminComponent, AdminUsersComponent],
  imports: [CommonModule, AdminRoutingModule],
})
export class AdminModule {}

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.