Skip to content

Angular Folha de referência

Framework de aplicações web baseado em TypeScript, mantido pelo Google.

01

Primeiros Passos

Configuração da CLI e Criação de Projeto

A Angular CLI é a ferramenta principal para o desenvolvimento. O ng new cria um projeto completo com roteamento e estilos já pré-configurados. Use ng generate (ng g) para criar arquivos de forma consistente. A CLI cuida do build, dos testes e do deploy.

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

Visão Geral da Estrutura do Projeto

O Angular impõe uma estrutura de pastas clara. src/app guarda o código de funcionalidades. O main.ts inicializa o componente raiz. O angular.json configura as opções de build, test e serve. A pasta de environments permite trocar URLs de API conforme o ambiente.

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

Servindo e Compilando

O ng serve inicia um servidor de desenvolvimento com recarregamento estilo HMR na porta 4200 por padrão. Builds de produção aplicam tree-shaking, minificação e hash nos nomes dos arquivos para cache. Use --stats-json com o webpack-bundle-analyzer para encontrar dependências infladas. O ng test roda o Karma por padrão.

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

Gerando Código (Schematics)

Os schematics garantem nomenclatura de arquivos e boilerplate consistentes. A flag --standalone gera componentes standalone (recomendado desde a v17). --route + --module conecta uma rota com lazy loading automaticamente. Guards criados com --functional retornam uma função em vez de uma classe.

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

Configuração (angular.json)

O angular.json é a configuração do workspace. Cada projeto tem targets de build, serve, test e lint. Os budgets emitem avisos ou erros quando os bundles excedem os limites. O array polyfills inclui o zone.js exigido pelo Angular. Vários projetos (app + biblioteca) podem coexistir em um mesmo 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 (Ambientes)

O Angular troca os arquivos de environment durante o build conforme a configuração (dev vs prod). As substituições de arquivos são configuradas no angular.json em fileReplacements. Injete o objeto de environment em qualquer lugar para acessar valores específicos do ambiente sem URLs fixas no código. Nunca faça commit de segredos reais no controle de versão.

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

Noções Básicas de Componentes

Componente Básico

Um componente é uma classe TypeScript decorada com @Component. O selector é a tag HTML personalizada usada nos templates. templateUrl/styleUrls apontam para arquivos externos; use template/styles para inline. @Input marca propriedades que os componentes pais podem vincular. Mantenha os componentes focados em uma única responsabilidade.

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}!`;
  }
}

Componente com Template Inline

Templates inline são convenientes para componentes pequenos e evitam arquivos extras. Use crases para strings de várias linhas — escape as crases internas como \`. styles aceita um array de strings CSS. O seletor :host mira o próprio elemento do componente. Prefira arquivos externos quando o template passar de ~10 linhas.

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--; }
}

Componente Standalone (v14+)

Componentes standalone não precisam de um NgModule — eles declaram seu próprio array imports listando as dependências (CommonModule, FormsModule, outros componentes). Essa é a abordagem moderna recomendada. Importe apenas o que usar para melhorar o tree-shaking. Inicialize componentes standalone diretamente no 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 e Outputs

@Input permite que os pais passem dados via property bindings. @Output expõe um EventEmitter que os pais assinam via event bindings. Sempre inicialize os inputs com valores padrão para evitar erros de undefined. Use a nova API de signals input()/output() para um código mais limpo na v17+.

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)" />

Inputs Baseados em Signals (v17.1+)

A função input() cria um input baseado em signal, somente leitura, que você chama como uma função. Ela suporta inputs obrigatórios via input.required<T>(), transforms, e funciona perfeitamente com computed() e effect(). O output() é a substituição moderna do @Output EventEmitter. Este é o futuro das APIs de componentes do 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());
}

Encapsulamento de View

Emulated (padrão) adiciona atributos únicos para escopar os estilos ao componente sem Shadow DOM real. None deixa os estilos globais (use com moderação). ShadowDom usa Shadow DOM nativo para isolamento verdadeiro, mas afeta a penetração de estilos e algumas bibliotecas de terceiros. Fique com Emulated, a menos que tenha necessidades específicas.

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

Sintaxe de Template

Interpolação de Texto

Chaves duplas {{ }} renderizam expressões como texto, com escape de HTML. Você pode usar a maioria das expressões JS: aritmética, ternário, chamadas de função, acesso a propriedades. Sem new, typeof ou operadores de atribuição. Pipes (|) transformam a saída. A interpolação é reavaliada a cada ciclo de detecção de mudanças.

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 -->

Property e Attribute Binding

[prop] faz binding a uma propriedade do DOM (preferível). [attr.name] faz binding a atributos HTML para casos sem propriedade de DOM correspondente (colspan, atributos SVG). [class.x] alterna uma única classe conforme a veracidade; [style.prop] define um estilo, com sufixo de unidade opcional como .px ou %. Evite fazer binding a innerHTML com conteúdo não confiável.

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 Binding

(event) faz binding a eventos do DOM e a outputs personalizados de EventEmitter. $event é o payload do evento (um DOM Event para eventos nativos, o valor emitido para eventos personalizados). Modificadores de evento como .enter, .esc, .prevent, .stop filtram ou transformam eventos. O alvo entre parênteses determina o que dispara o handler.

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>

Variáveis de Referência de Template

Uma #var (ou ref-var) referencia o elemento do DOM ou a instância de componente onde ela é declarada. Fica acessível em qualquer lugar do template. Para componentes, o valor é a instância do componente; para elementos, é o HTMLElement. Dentro de @for, $index, $first, $last, $even, $odd são variáveis de contexto implícitas.

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>

Two-Way Binding (Banana in a Box)

[(ngModel)] exige o FormsModule. A sintaxe [(x)] se expande para [x] + (xChange), então bindings two-way personalizados precisam de um input chamado x e um output chamado xChange. Lembre do mnemônico 'banana in a box' — os parênteses ficam dentro dos colchetes. A função de signal model() simplifica isso a partir da 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);

Safe Navigation e Non-Null Assertion

O operador ?. navega com segurança por cadeias que podem ser nulas, retornando undefined em vez de lançar erro. Use-o para dados assíncronos ainda não carregados. O operador ! é apenas uma asserção em tempo de compilação — ele não adiciona verificações em runtime, então use somente quando tiver certeza. Para arrays que podem ser nulos, use ?? [] como fallback.

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

Diretivas

@if / @else (Novo Fluxo de Controle)

A nova sintaxe de blocos @if/@else if/@else substitui o *ngIf. Não é preciso importar CommonModule ou NgIf, sem asterisco, e o @else funciona nativamente (diferente do truque com ng-template do ngIf). Esta é a sintaxe recomendada para código novo. Ela faz parte do fluxo de controle embutido introduzido na v17 e estável na 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 (Novo Fluxo de Controle)

O @for substitui o *ngFor com expressão track obrigatória para um DOM diffing eficiente. O @empty renderiza conteúdo alternativo quando a coleção está vazia. As variáveis de contexto implícitas ($index, $first, $last etc.) estão sempre disponíveis. Rastrear por um id único e estável é crítico para a performance em listas grandes.

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 e ngStyle

O ngClass aceita um objeto (chaves verdadeiras são aplicadas), array ou string. O ngStyle aceita um objeto com chaves em camelCase ou kebab-case, com sufixos de unidade opcionais. Requer importar CommonModule ou as diretivas específicas. Para uma única classe/estilo, [class.x] e [style.x] são mais leves e não exigem imports.

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 (Novo Fluxo de Controle)

O @switch substitui o *ngSwitch (e as diretivas ngSwitchCase/ngSwitchDefault). É mais limpo — não precisa de container envelopador nem imports. Cada @case é renderizado apenas quando seu valor corresponde à expressão do @switch. O @default é o fallback. Esse é o fluxo de controle embutido disponível na 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>
  }
}

Diretiva de Atributo Personalizada

Diretivas de atributo mudam a aparência ou o comportamento de elementos do DOM. Os [colchetes] no selector correspondem ao uso como atributo. O ElementRef dá acesso direto ao DOM; o HostListener faz binding a eventos do DOM. Injete ElementRef<HTMLElement> para segurança de tipos. Prefira o Renderer2 para manipulação do DOM em cenários de renderização no servidor.

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> -->

Como Funcionam as Diretivas Estruturais

Diretivas estruturais adicionam/removem nós do DOM via TemplateRef (o template envelopado) e ViewContainerRef (onde inserir). O asterisco (*) é um açúcar sintático que envolve o elemento em um <ng-template>. Os novos blocos @if/@for/@switch substituem a maioria das diretivas estruturais personalizadas, mas esse padrão ainda é útil em casos avançados.

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

Pipes

Pipes Embutidos

Pipes transformam valores exibidos no template. Os mais comuns: date, number, currency, percent, uppercase, lowercase, titlecase, slice, json, async. Pipes são puros por padrão — recalculam apenas quando a referência do input muda. As strings de formato seguem as regras de locale do 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>

Encadeamento de Pipes e Parâmetros

Pipes se encadeiam da esquerda para a direita, cada um recebendo a saída do anterior. Os parâmetros são separados por dois-pontos e posicionais. Use-os para transformações puras (formatação, filtragem) para manter os templates declarativos. Evite pipes impuros para dados sensíveis à performance; faça o cálculo no componente.

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>

Pipe Personalizado

Pipes personalizados implementam PipeTransform.transform(). O nome do @Pipe é usado nos templates. Registre pipes standalone (v15+) no array imports de um componente, ou declare-os em um NgModule. Pipes puros (padrão) só rodam de novo quando a referência do input muda — passe referências novas para disparar atualizações.

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>

Pipe Async

O pipe async assina um Observable ou Promise, renderiza o valor e cancela a assinatura automaticamente ao destruir — sem necessidade de subscribe/unsubscribe manual. Combinado com *ngIf as ou @for, ele trata null durante o carregamento de forma elegante. Ele marca o componente para verificação quando chega um novo valor, integrando-se ao 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) {}
}

Pipes Puros vs Impuros

Pipes puros armazenam em cache os resultados até que a referência do input mude; mutar arrays ou objetos não os dispara. Pipes impuros (pure: false) rodam a cada detecção de mudança — convenientes para filtrar arrays mutados, mas custosos. Prefira manter os dados imutáveis (substitua arrays em vez de mutá-los) e use pipes puros por questões de performance.

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.

Pipes de i18n e Locale

Pipes como date, number, currency respeitam o LOCALE_ID. Registre os dados de locale via registerLocaleData antes do bootstrap. Os formatos de moeda/número seguem o locale ativo. Para apps multilíngues, forneça o LOCALE_ID por usuário ou use as ferramentas de i18n para traduções nos templates. Dados de locale ausentes usam en-US como fallback.

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

Serviços e Injeção de Dependência

Serviço Básico

providedIn: 'root' cria um singleton disponível no app inteiro sem registro em módulo. O serviço é tree-shakeable — removido se não for usado. Use a função inject() (v14+) em vez da injeção pelo construtor para um código mais limpo e testes mais fáceis. Serviços guardam estado compartilhado e lógica de negócio; componentes ficam presentacionais.

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);
}

Função inject()

inject() é a alternativa moderna à injeção pelo construtor. Funciona em inicializadores de campos, tornando o código mais legível e permitindo melhor inferência de tipos do TypeScript. Deve rodar durante a construção (não em callbacks assíncronos depois). Use-o de forma consistente — misturar parâmetros de construtor com inject() funciona, mas inject() é mais limpo.

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
}

Configuração de Providers

Providers podem ser configurados em qualquer nível (root, módulo, componente). useClass troca implementações (ótimo para mocks). useValue fornece constantes. useExisting cria um alias de um serviço para outro. useFactory cria instâncias dinamicamente. InjectionToken é para valores que não são classes, como strings ou objetos de configuração.

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');

Injetores Hierárquicos

A árvore de DI do Angular espelha a árvore de componentes. providedIn: 'root' = uma instância para o app inteiro. Providers no nível do componente criam injetores filhos — cada instância recebe o seu. Isso é útil para componentes com estado, como editores. 'any' escopa para módulos lazy. 'platform' é raro, usado em configurações com múltiplos apps.

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 Providers e Tokens

multi: true registra vários providers sob um mesmo token, injetados como um array. Útil para sistemas de plugins, interceptors, validators ou qualquer coleção extensível. A ordem de injeção segue a ordem de registro. Combine com InjectionToken para tipar o array corretamente.

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[]
}

Providers Opcionais e Padrão

@Optional() ou inject(token, { optional: true }) retorna null se nenhum provider for encontrado, em vez de lançar erro. Use para dependências não críticas. Outros modificadores: @SkipSelf() (não verifica o injetor atual), @Self() (somente o atual), @Host() (até o componente host). Os equivalentes de inject() aceitam flags no objeto de opções.

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

Roteamento

Configuração de Rotas

Rotas mapeiam caminhos de URL para componentes. loadComponent/loadChildren habilitam lazy loading (bundle inicial menor). :id é um parâmetro de rota. O curinga '**' captura URLs não correspondentes — coloque-o por último. O provideRouter configura o router em apps standalone. Defina title para os nomes das abas do navegador; pode ser uma string ou um 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 e Links

O router-outlet marca onde os componentes roteados são renderizados. O routerLink cria links de navegação (use a forma de array para parâmetros). O routerLinkActive aplica uma classe quando a rota corresponde. Navegação programática usa router.navigate() ou routerLink. Outlets nomeados habilitam rotas secundárias (ex.: um modal junto à view principal).

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]); }

Parâmetros de Rota e Query Params

Use snapshot para leituras únicas quando o componente é destruído e recriado a cada navegação. Use o observable paramMap/queryParamMap quando a mesma instância de componente trata parâmetros diferentes (ex.: navegar de /users/1 para /users/2). Sempre cancele a assinatura ou use o pipe async para evitar vazamentos.

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 }">

Rotas Filhas e Aninhadas

Rotas filhas são renderizadas em um router-outlet aninhado dentro do componente pai. redirectTo com pathMatch: 'full' redireciona caminhos filhos vazios. Esse padrão constrói layouts master-detail (moldura do pai, conteúdo do filho). Cada nível de aninhamento precisa do seu próprio router-outlet no template do pai.

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 -->

Lazy Loading

O lazy loading divide o app em chunks carregados sob demanda, reduzindo o bundle inicial. loadChildren carrega um arquivo de rotas (export default de Routes); loadComponent carrega um único componente standalone. A string do import() dinâmico deve ser um caminho estático para o bundler dividir corretamente. Use isso para áreas de funcionalidades acessadas por navegação.

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 },
];

Eventos do Router e Navegação

Os eventos do router (NavigationStart, NavigationEnd, GuardsCheckStart etc.) permitem acompanhar o ciclo de vida da navegação. Sempre filtre para eventos específicos e cancele a assinatura. O router.navigate aceita extras: queryParams, fragment, state (dados transitórios que não ficam na URL) e replaceUrl. O state pode ser lido via 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

Formulários

Formulário Template-driven

Formulários template-driven usam ngModel e referências de template. O FormsModule é obrigatório. O estado do formulário (validade, touched, dirty) é rastreado pelas diretivas ngForm e ngModel. Ideal para formulários simples. A validação é declarada no template (required, minlength, pattern). Acesse o estado de controle via referências de template como #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); }
}

Configuração de Formulários Reativos

Formulários reativos definem o modelo na classe do componente como instâncias de FormControl/FormGroup. O ReactiveFormsModule é obrigatório. O formControlName liga inputs a controls. O modelo do formulário é observável e testável sem o DOM. nonNullable: true evita valores null quando o input é limpo. Preferível para formulários complexos.

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 e Typed Forms

O FormBuilder reduz o boilerplate. fb.group() infere os tipos a partir dos valores padrão. Grupos aninhados modelam dados aninhados. O FormArray gerencia listas dinâmicas de controls. Com nonNullable, os controls mantêm o tipo declarado em vez de null. Use get() ou controls para acesso type-safe. Typed forms (v14+) dão autocomplete e verificação de tipos no 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)); }
}

Validação de Formulários

Validators.required, .minLength, .maxLength, .pattern, .email, .min, .max são embutidos. Aplique vários via um array. A validação cruzada de campos fica no FormGroup, com uma função validadora que recebe o grupo inteiro. Verifique control.touched/dirty antes de mostrar erros para não repreender os usuários na primeira renderização. Use .hasError('key') para testar erros específicos.

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> -->

Validador Personalizado

Validadores personalizados são funções que retornam ValidationErrors (um mapa) ou null se válido. Validadores assíncronos retornam um Observable ou Promise — use-os para checagens no servidor, como disponibilidade de nome de usuário. Sempre aplique debounce em validadores assíncronos (via timer/switchMap) para não sobrecarregar o servidor a cada tecla.

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),
    );
  };
}

Mudanças de Valor e Estado do Formulário

valueChanges e statusChanges são Observables que emitem a cada input. O debounceTime evita trabalho excessivo em digitação rápida. takeUntil com um Subject é a forma idiomática de cancelar a assinatura ao destruir. patchValue atualiza valores parciais do formulário; setValue exige o valor de cada campo. Use { emitEvent: false } para atualizar silenciosamente sem disparar 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

Configuração e GET Básico

provideHttpClient() registra o client no app inteiro. As funções do HttpClient retornam Observables frios — só executam quando assinados (use o pipe async nos templates ou subscribe nos serviços). As respostas são tipadas via generics. Sempre trate erros de forma centralizada ou por chamada. O withFetch() (v18) ativa o backend moderno baseado em 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 retornam Observables que emitem a resposta uma vez e completam. Passe o body como segundo argumento. O tipo genérico restringe a resposta. A URL pode ser um template literal com parâmetros. Sempre faça subscribe — Observables são frios e não disparam de outra forma. Considere toPromise() (obsoleto) ou firstValueFrom() para leituras de uso único.

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 Parameters e Headers

params aceita um objeto, HttpParams ou array — o Angular os codifica na query string. headers define os headers da requisição. observe: 'response' retorna o HttpResponse completo (status, headers, body) em vez de só o body. observe: 'events' com reportProgress transmite eventos de progresso para upload/download de arquivos.

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',
    });
  }
}

Interceptors

Interceptors funcionais (v15+) são funções simples encadeadas via withInterceptors(). Eles rodam em ordem para cada requisição — perfeitos para tokens de autenticação, logging, lógica de retry ou cache. clone() cria uma requisição modificada (requisições são imutáveis). A função next(req) retorna o stream de resposta — operadores pipe como retry e catchError se aplicam aqui.

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),
  }));
};

Tratamento de Erros

Use operadores RxJS para resiliência HTTP: retry reassina em caso de erro, timeout aborta requisições lentas, catchError mapeia erros para valores alternativos ou relança. Sempre trate erros também no lado do consumidor — erros de Observable não capturados encerram o stream. Faça subscribe com os callbacks next/error/complete para lidar com o ciclo de vida completo.

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,
});

Respostas Tipadas e withFetch

Generics tipam o corpo da resposta, mas não validam em runtime — para segurança, use um validador de runtime como o zod. observe: 'response' expõe status, headers e body. O withFetch() (v18) usa a Fetch API em vez de XHR, habilitando streaming e melhor renderização no servidor. O withXsrfConfiguration adiciona tratamento automático de token 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 e RxJS

Observable Básico

Observables são lazy — o produtor só roda quando assinado. Podem emitir zero ou mais valores e então completar ou errar. O callback do subscribe recebe next, error, complete. Sempre cancele a assinatura de subscriptions de longa duração (ou use o pipe async / takeUntilDestroyed). of() emite valores sincronamente; from() achata arrays ou promises.

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);

Operadores Comuns

Operadores transformam streams. map/filter funcionam como as funções de array. debounceTime espera um período de silêncio (ótimo para campos de busca). distinctUntilChanged ignora valores duplicados consecutivos. switchMap cancela o Observable interno anterior quando chega um novo valor — perfeito para busca enquanto digita. Operadores pipe da esquerda para a direita.

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);

Combinando Streams

combineLatest emite sempre que qualquer fonte emite (depois que todas emitiram pelo menos uma vez) — ótimo para estado de view derivado. forkJoin espera todas as fontes completarem, retornando o último valor de cada — use para requisições HTTP em paralelo. merge intercala emissões. zip pareia por índice. race escolhe o primeiro Observable a emitir e ignora o resto.

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 (Multicast)

Subjects são tanto Observables quanto Observers — chame .next() para enviar valores. Subject: sem valor inicial, assinantes tardios perdem emissões anteriores. BehaviorSubject: exige valor inicial, novos assinantes recebem imediatamente o valor atual (use para estado). ReplaySubject: armazena em buffer os últimos N valores para novos assinantes (use para reproduzir eventos).

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 e Limpeza

takeUntil(unsubscribe$) completa automaticamente uma subscription quando o notificador emite — o padrão clássico para evitar vazamentos em componentes. takeUntilDestroyed() (v16+) usa o DestroyRef do Angular para cancelar a assinatura automaticamente, sem boilerplate de OnDestroy. Deve ser chamado em um contexto de injeção (construtor ou inicializador de campo) ou aceitar um DestroyRef explicitamente.

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

Esses operadores de achatamento diferem em como tratam Observables internos sobrepostos. switchMap cancela (busca enquanto digita). mergeMap paraleliza (carregar muitos). concatMap enfileira (preservar ordem). exhaustMap descarta (evitar duplo envio). Escolher o errado causa race conditions — combine o operador com a semântica de cancelamento do caso de uso.

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

Hooks de Ciclo de Vida

Visão Geral da Ordem dos Hooks

Os hooks disparam em uma ordem estrita. ngOnChanges dispara em mudanças de @Input (e inicialmente). ngOnInit dispara uma vez após o primeiro ngOnChanges. ngDoCheck roda a cada ciclo de detecção de mudanças. Os hooks After* sinalizam que o conteúdo/view está pronto para consultas ao DOM. ngOnDestroy é o ponto de limpeza — cancele assinaturas, libere recursos, cancele timers.

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 e ngOnDestroy

ngOnInit roda uma vez após os inputs serem definidos — o lugar certo para inicialização pesada (fetches, subscriptions), já que o construtor deve ficar leve. ngOnDestroy é o único hook chamado na destruição do componente — nunca pule a limpeza aqui, senão você vaza subscriptions, timers e event listeners. O construtor é só para DI; use o ngOnInit para lógica.

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 dispara sempre que a referência de um @Input muda, com um mapa SimpleChanges: cada entrada tem previousValue, currentValue, firstChange e isFirstChange(). Ele NÃO dispara quando você muta propriedades de um objeto — apenas quando a referência muda. Para mudanças profundas, use ngOnChanges com um setter ou ngDoCheck com 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 e ViewChild

As consultas ViewChild/ContentChild resolvem DEPOIS dos respectivos hooks de init. ngAfterViewInit para elementos no próprio template do componente; ngAfterContentInit para conteúdo projetado via <ng-content>. Acessar essas referências no ngOnInit retorna undefined. A asserção não nula ! informa ao compilador que o valor é definido após o init — mas só é usada com segurança nos hooks 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 (Detecção Personalizada)

ngDoCheck roda a cada ciclo de detecção de mudanças — mantenha-o leve. Use IterableDiffers/KeyValueDiffers para detectar mutações em arrays/objetos que o ngOnChanges não percebe (já que as referências não mudam). Esta é a válvula de escape para rastrear mutações internas. Evite lógica pesada aqui; ela roda com frequência e pode causar problemas de performance.

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));
    }
  }
}

Hooks de Content vs View

Hooks de content (AfterContentInit/Checked) disparam para conteúdo projetado via <ng-content>. Hooks de view (AfterViewInit/Checked) disparam para o próprio template do componente. Os hooks de content disparam ANTES dos de view porque o conteúdo é inicializado antes de a view completar. @ContentChild consulta elementos projetados; @ViewChild consulta elementos do próprio template.

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

Projeção de Conteúdo

ng-content Básico

<ng-content> é um espaço reservado onde o conteúdo fornecido pelo pai é projetado. Pense nele como o <slot> do Angular. Sem select, o conteúdo projetado inteiro vai para lá. O conteúdo projetado é compilado no contexto do pai — bindings como {{ }} resolvem contra o componente pai, não contra o 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>

Projeção Multi-slot

O atributo select no ng-content mira conteúdo projetado específico: por elemento ('header'), atributo ('[header]'), classe ('.active') ou combinações ('div.foo[bar]'). Conteúdo sem correspondência cai no ng-content sem select. O conteúdo projetado mantém os estilos e o contexto do pai — apenas sua posição no DOM muda.

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>

Projeção Condicional (ng-template)

Para projeção condicional ou repetida, ng-template com ngTemplateOutlet dá controle total. ContentChildren consulta diretivas projetadas. O ngTemplateOutlet renderiza um TemplateRef em um local escolhido — útil para tabs, accordions ou slots condicionais. Esse padrão desacopla a declaração do conteúdo de onde e quando ele é renderizado.

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 e ContentChildren

@ContentChild / @ContentChildren consultam o conteúdo projetado (vs ViewChild para o próprio template). ContentChildren retorna um QueryList que é atualizado quando o conteúdo muda. Resolva no ngAfterContentInit. A opção { descendants: true } (padrão) percorre o conteúdo projetado inteiro. Use { read: ... } para consultar um tipo específico (ElementRef, TemplateRef etc.).

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 com Contexto

O ngTemplateOutlet renderiza um TemplateRef com um contexto opcional. let-x faz binding a context.$implicit (o valor padrão); let-y='key' faz binding a context.key. É assim que o *ngFor e o ngTemplateOutlet passam variáveis de loop. Use esse padrão para templates reutilizáveis de lista/grid/item que os pais podem personalizar enquanto o componente controla a lógica de iteração.

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' }];
}

Padrões de select do ng-content

O select aceita seletores semelhantes a CSS: classes (.x), atributos ([x]), elementos (header) ou listas separadas por vírgula ('a, b'). Conteúdo que não corresponde a nenhum seletor cai no ng-content sem select. Se não houver fallback, o conteúdo sem correspondência é descartado. Os seletores correspondem aos próprios atributos dos elementos projetados, não à sua estrutura interna.

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

Route Guards

CanActivate (Funcional)

Guards funcionais (v14.2+) retornam true/false/UrlTree ou um Observable/Promise deles. Retornar um UrlTree redireciona para aquela rota. inject() funciona porque os guards rodam em um contexto de injeção. CanActivate impede a navegação para uma rota. Registre guards por rota no array canActivate. Eles rodam a cada navegação para aquela rota.

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 roda antes de cada rota filha sob o pai — mais limpo do que repetir canActivate em cada filho. Use para proteção compartilhada de uma área de funcionalidade. Retorna os mesmos tipos de valor que CanActivate. Para proteger também o próprio pai, adicione canActivate na rota pai.

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 (Guard para Mudanças Não Salvas)

CanDeactivate roda antes de sair de uma rota — perfeito para avisar sobre alterações de formulário não salvas. O guard recebe a instância do componente, então chama uma função nela. Retorne false para cancelar a navegação, true para prosseguir. Para async (confirmação em modal), retorne um Observable ou Promise. O componente deve implementar o contrato que o guard espera.

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 (Carregamento Condicional)

CanMatch (v14.1+) roda antes mesmo do chunk de uma rota lazy ser baixado — mais eficiente que CanActivate para restringir recursos pagos. Se retornar false, a rota é ignorada completamente (outras rotas correspondentes ganham a chance). O CanActivate carregaria o chunk primeiro e depois negaria. Use CanMatch para impedir o download de código que o usuário não pode acessar.

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 (Pré-buscar Dados)

Resolve roda antes da rota ser ativada, atrasando a navegação até os dados chegarem. Os dados resolvidos ficam em route.snapshot.data. Útil para garantir que os componentes tenham dados ao renderizar (sem flash de estado vazio). Trate erros dentro do resolver — retornar EMPTY cancela a navegação. Para cargas não bloqueantes, faça o fetch no 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) {}
}

Composição e Ordenação de Guards

Vários guards rodam na ordem do array; o primeiro a falhar cancela a navegação. canMatch roda antes de os chunks lazy carregarem; canActivate roda depois. canDeactivate roda ao sair. Os guards podem ser síncronos (retornar boolean) ou assíncronos (Observable/Promise). Mantenha-os rápidos — eles bloqueiam a UI. Checagens pesadas no servidor devem ter debounce ou cache.

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

Resolvers

Resolver Básico (ResolveFn)

ResolveFn é a API funcional de resolvers. Roda antes de a navegação completar, e o valor retornado é colocado em route.data sob a chave que você atribuir. O componente pode lê-lo sincronamente de snapshot.data — sem necessidade de estado de carregamento. Assine route.data para atualizações reativas ao navegar entre rotas do mesmo componente.

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']);
  }
}

Múltiplos Resolvers

Vários resolvers rodam em paralelo — é preciso que cada um complete antes de a rota ser ativada. Cada chave em resolve vira uma chave em route.data. Se um falhar, a navegação é cancelada. Para dados independentes, isso é eficiente. Se um depende de outro, aninhe-os ou encadeie em um único resolver. Considere as trocas entre resolver e fetch no 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
  }
}

Tratamento de Erros no Resolver

Trate erros de resolver explicitamente — erros não capturados cancelam a navegação silenciosamente. EMPTY completa o stream sem emitir, cancelando a navegação. Retornar null permite que o componente lide graciosamente com dados ausentes. Para 404s, redirecione para uma rota de não encontrado. Sempre registre ou exponha os erros; falhas silenciosas são difíceis de depurar para os usuários.

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);
    }),
  );
};

Resolver vs Fetch no ngOnInit

Resolvers bloqueiam a navegação até os dados chegarem — UX limpa, mas parece mais lento. O fetch no ngOnInit não bloqueia, mas exige estados de carregamento no componente. A orientação moderna do Angular pende para o não bloqueante: faça o fetch no componente com um skeleton de carregamento para melhor performance percebida. Use resolvers apenas quando o componente realmente não pode renderizar sem os dados.

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;
      });
    });
  }
}

Resolver com Query Params e Signals

Resolvers podem ler tanto paramMap quanto queryParamMap da rota. Quando o mesmo componente trata parâmetros diferentes, assine route.data de forma reativa em vez de usar snapshot. Com signals, atualize um signal a partir da subscription de dados. Combine resolvers com signals para um fluxo de dados limpo e reativo. Evite resolvers pesados — eles bloqueiam a navegação.

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

Animações

Configuração e Animação Básica

provideAnimations() registra o módulo de animações. trigger() define uma animação nomeada; transition() declara a mudança entre estados. :enter e :leave são pseudo-estados embutidos para elementos adicionados/removidos via *ngIf ou @if. Aplique via @triggerName no template. Para o fluxo de controle da v17+, as animações continuam funcionando com @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>`,
})

Estados e Transições

state() define estilos nomeados em repouso. transition('a => b') anima do estado a para o b; '<=>' é bidirecional. Vincule o trigger a uma expressão que retorna o nome do estado. Estilos de estado são aplicados imediatamente (sem animação); transições animam entre eles. Use 'void' para elementos ainda não presentes no DOM, e '*' como curinga.

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 e Animações Paralelas

keyframes() define etapas intermediárias com offset (0 a 1) para controle fino — como os @keyframes do CSS. group() roda animações em paralelo; sequence() roda uma após a outra. Use-os para compor efeitos complexos de entrada/saída. Mantenha as animações curtas (200-400ms) e respeite prefers-reduced-motion para acessibilidade.

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)' })),
  ]),
]),

Lista Animada (@for)

Aplique animações :enter/:leave aos itens do @for — elas disparam quando itens são adicionados ou removidos. O track garante que o Angular identifique corretamente os itens entre mudanças, então as animações disparam em adição/remoção reais (não em reordenação). Animações em listas podem ficar travadas sem um track adequado. Para animações de reordenação, use query() e 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 = [...]; }

Animações de Router

Vincule o trigger de animação ao estado de ativação do router-outlet. query(':enter'/:leave) mira os componentes roteados que entram/saem. { optional: true } evita erros quando um lado não existe (a carga inicial não tem :leave). position: absolute empilha os componentes antigo e novo durante a transição. Animações de rota dão transições com cara de app entre views.

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>
  `,
})

Movimento Reduzido e Animações CSS

Sempre respeite prefers-reduced-motion por acessibilidade — alguns usuários ficam enjoados com movimento. As animações do Angular adicionam ~50KB ao bundle; para fades simples, animações CSS puras podem bastar. Use animações do Angular quando precisar de transições com estado (máquinas de estado), coordenação pai-filho ou animações de rota. CSS é mais leve para efeitos de hover/fade.

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

Testes

Configuração de Teste de Componente

O TestBed configura o módulo de testes. Para componentes standalone, importe-os diretamente (não são necessárias declarations no TestBed.configureTestingModule). createComponent retorna uma ComponentFixture: use .componentInstance para a classe, .nativeElement para o DOM e .detectChanges() para disparar a detecção de mudanças. beforeEach com async/await cuida do 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();
  });
});

Testando com Serviços Mock

Forneça implementações mock dos serviços para isolar o componente em teste. jasmine.createSpy() permite controlar valores de retorno e verificar chamadas. Use useValue para mocks de objeto, useClass para fakes baseados em classe. Sobrescreva o HttpClient com HttpTestingController para testes HTTP. Mocking mantém os testes rápidos e determinísticos — sem chamadas de rede reais.

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);
  });
});

Testes HTTP

HttpTestingController intercepta chamadas do HttpClient nos testes — sem rede real. expectOne verifica que uma requisição foi feita e a retorna; flush() simula a resposta do servidor. verify() garante que não restem requisições sem correspondência. Teste caminhos de sucesso e de erro: flush com um código de status (ex.: { status: 500, statusText: 'Server Error' }) para simular erros.

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
  });
});

Testando Template e Interações

fixture.nativeElement dá acesso direto ao DOM para asserções. detectChanges() sincroniza os bindings do template após definir propriedades. spyOn permite verificar chamadas de funções. Para consultas internas do componente, debugElement.query(By.css()) é type-safe. Dispare eventos via funções nativas do DOM (click()) ou DebugElement.triggerEventHandler para eventos personalizados.

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'));

Testando Signals

Signals são funções — chame-as (com parênteses) para ler valores nos testes. set() atualiza signals graváveis diretamente, evitando a necessidade de manipulação indireta. detectChanges() sincroniza templates orientados a signals. Para computed/effect, detectChanges ou TestBed.flushEffects() garante que os effects dependentes rodem. Signals tornam os testes mais síncronos e previsíveis.

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 com Cypress / Playwright

Testes E2E exercitam o app inteiro em um navegador real. Use atributos data-cy como seletores — são estáveis e não se acoplam a classes CSS. O Cypress roda no navegador; o Playwright roda em vários navegadores. Use ng e2e ou configure Cypress/Playwright manualmente. Testes E2E pegam problemas de integração que testes unitários perdem, mas são mais lentos — mantenha a suíte enxuta.

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

Adicionando Suporte a PWA

ng add @angular/pwa cria tudo: registro do service worker, web manifest e ícones. O service worker só roda em builds de produção (ng build --configuration production) — fica desativado em dev para evitar surpresas de cache. registrationStrategy controla quando o SW se registra; registerWhenStable espera o app estabilizar.

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',
    }),
  ],
};

Configuração do Service Worker (ngsw-config.json)

assetGroups faz cache do app shell (prefetch) e dos assets estáticos (lazy). dataGroups faz cache de respostas de API com estratégias de freshness/performance e TTLs. prefetch baixa com antecedência; lazy baixa sob demanda. freshness tenta a rede primeiro e cai para o cache (bom para dados frescos); performance usa cache primeiro (bom para dados quase estáticos).

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"
      }
    }
  ]
}

Lidando com Atualizações

SwUpdate notifica quando uma nova versão está disponível. VERSION_READY significa que um novo bundle foi baixado e está pronto para ativar. activateUpdate() troca para a nova versão; recarregue para carregá-la. Para atualizações críticas, force a ativação imediatamente. Para não críticas, pergunte ao usuário. Assine versionUpdates para tratar VERSION_DETECTED, VERSION_READY e 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());
  }
}

Suporte Offline e Cache

SwPush habilita notificações web push via service worker. requestSubscription pede permissão ao usuário e retorna um objeto de subscription para enviar ao seu servidor. O SW recebe eventos de push mesmo com a aba fechada. As chaves VAPID autenticam seu servidor. Combine com a Notification API para exibir mensagens; trate os cliques para navegar dentro do app.

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');
    }
  }
}

App Manifest

O web manifest torna o app instalável (Adicionar à Tela Inicial). name/short_name aparecem na tela inicial; theme_color colore a UI do navegador; display: standalone remove a moldura do navegador para dar cara de app. Forneça vários tamanhos de ícone (192, 512) mais um ícone maskable para Android. Teste com o audit de PWA do Lighthouse para verificar a instalabilidade.

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" }
  ]
}

Instalabilidade e Lighthouse

beforeinstallprompt dispara no Chrome quando o app é instalável, mas permite adiar o prompt nativo. Salve o evento e dispare prompt() a partir de um gesto do usuário (clique em botão). O iOS Safari não dispara esse evento — usuários instalam pelo menu Compartilhar. Rode o audit de PWA do Lighthouse para verificar a instalabilidade. PWAs funcionam offline apenas quando o service worker faz cache do app shell.

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

Componentes Standalone

Bootstrap Standalone

bootstrapApplication inicia um app standalone — sem NgModule. O AppComponent raiz deve ser standalone. O app.config.ts centraliza os providers (router, http, animations, config de zone). Esse é o padrão desde a v17. Cada função provideX() conecta um subsistema. Bem mais limpo que AppModule + providers do 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(),
  ],
};

Imports de Componentes Standalone

standalone: true marca o componente como autocontido. O array imports lista tudo que o template precisa: módulos, componentes, diretivas, pipes. Com o fluxo de controle da v17+ (@if/@for), você não precisa de CommonModule para eles. Importe apenas o que é usado para melhor tree-shaking. Componentes standalone podem ser usados em NgModules via 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 { ... }

Rotas Standalone e Lazy Loading

loadComponent carrega com lazy loading um único componente standalone — o menor chunk possível. loadChildren carrega com lazy loading um arquivo de rotas (export default de Routes). Ambos usam import() dinâmico com caminho estático para o bundler dividir. Isso substitui completamente os feature modules. Cada rota lazy ganha seu próprio arquivo JS, carregado na primeira navegação.

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),
  },
];

Diretivas e Pipes como Standalone

Diretivas e pipes também podem ser standalone (v15+). Adicione standalone: true e importe-os em qualquer componente que precise deles. Isso elimina a necessidade de declará-los em um módulo compartilhado. Para compatibilidade retroativa, diretivas/pipes standalone ainda podem ser adicionados aos exports de um NgModule para uso em componentes baseados em 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>`,
})

Migrando de NgModule

O schematic automatiza a migração: torna todas as declarations standalone, move os imports do NgModule para o array imports de cada componente e remove módulos obsoletos. Rode-o incrementalmente — pode ser parcial. Após a migração, você pode apagar AppRoutingModule, AppModule e usar bootstrapApplication. O resultado é um app mais enxuto e com melhor 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 {}

Injeção em Providers Standalone

Apps standalone configuram providers no app.config.ts em vez do AppModule. APP_INITIALIZER roda a configuração antes do bootstrap. Providers no nível do componente escopam para a subárvore daquele componente. Para serviços, providedIn: 'root' continua preferível — é tree-shakeable. Use arrays de providers para valores que não são serviços (tokens, configs, mocks).

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

Criando Signals

signal() cria um valor reativo. Leia chamando-o: count(). Atualize com set() (substituir) ou update() (calcular a partir do anterior). Signals são síncronos e evitam a sobrecarga de Observables para estado simples. Nos templates, você pode chamá-los com () — a v17.2+ também desembrulha automaticamente em alguns contextos. Signals se integram à detecção de mudanças 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 Signals

computed() cria um signal derivado, somente leitura, que rastreia automaticamente suas dependências e faz cache do valor. Ele só recalcula quando uma dependência muda E é lido novamente — avaliação lazy. Computed signals podem depender de outros computed signals, formando um grafo. Diferente de funções, eles fazem cache dos resultados. Isso substitui muitos usos de combineLatest do RxJS.

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
}

Effects (Efeitos Colaterais)

effect() roda um efeito colateral quando suas dependências de signal mudam. Use para logging, sincronizar com localStorage, buscar dados ou manipular o DOM. Effects rodam depois da detecção de mudanças. Evite escrever em signals lidos no mesmo effect — isso cria loops infinitos. onCleanup registra lógica de teardown para a próxima execução. Effects devem ser criados em um contexto de injeção.

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));
  });
}

Signals em Templates (OnPush)

Signals se integram perfeitamente ao OnPush — o Angular sabe exatamente quais views dependem de um signal e marca apenas essas para verificação quando ele muda. Sem necessidade de markForCheck() manual. Nos templates, chame os signals com () para ler. OnPush + signals é a configuração de detecção de mudanças mais eficiente, muitas vezes permitindo dispensar o zone.js por completo (modo 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(''); }
}

Inputs e Queries de Signal

input()/input.required() criam inputs de signal somente leitura. output() cria outputs tipados. model() cria inputs de signal com binding two-way (com output xChange gerado automaticamente). viewChild()/contentChild() retornam signals que resolvem após o init da view — chame-os com () para ler. Essas APIs modernas substituem os decorators @Input/@Output/@ViewChild por signals reativos.

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(); }
}

Interop entre Signals e RxJS

toSignal converte um Observable em signal (assina uma vez, cancela a assinatura ao destruir). toObservable faz o inverso. Use a interop para misturar signals (para estado síncrono) com RxJS (para fluxos assíncronos complexos como busca com debounce). takeUntilDestroyed cancela a assinatura automaticamente via DestroyRef. initialValue evita leituras de undefined antes da primeira emissão. Exige um contexto de injeção.

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 e Arquitetura

Estrutura de NgModule

NgModules organizam o app em blocos coesos. declarations lista o que o módulo possui. imports trazem os exports de outros módulos. exports expõem as declarations para quem importa. Só o módulo raiz define bootstrap. O Angular moderno favorece componentes standalone (sem NgModule), mas apps com NgModule ainda existem. Entenda ambos — bases de código antigas e algumas bibliotecas usam módulos.

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 e Shared Modules

SharedModule agrupa componentes/diretivas/pipes de UI comuns para reuso entre features — reexporte CommonModule e FormsModule para que quem importa não precise. Feature modules encapsulam uma área de funcionalidade; forChild() permite que o mesmo módulo se configure de forma diferente por import (ex.: roteamento). Em apps standalone, prefira componentes standalone individuais a shared modules.

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 e Serviços Singleton

CoreModule guarda singletons do app inteiro (serviços, interceptors, error handlers) e é importado uma única vez no AppModule. O guard no construtor evita reimportação acidental (que criaria instâncias duplicadas de serviços). Em apps standalone, esses providers vão para o app.config.ts. O padrão CoreModule é legado, mas você vai encontrá-lo em bases pré-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');
  }
}

Padrão forRoot vs forChild

forRoot configura a instância raiz (chamado uma vez no AppModule); forChild registra rotas filhas (chamado nos feature modules). Esse padrão é usado pelo RouterModule e por módulos de biblioteca que precisam de configuração. O Angular moderno o substitui por funções provideX() no app.config.ts. O padrão ainda aparece em bibliotecas de terceiros — entenda-o para integrações.

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 e Componentes Dinâmicos

entryComponents (obsoleto) listava componentes criados dinamicamente (diálogos, modais). O Angular moderno usa ViewContainerRef.createComponent() ou NgComponentOutlet — sem necessidade de registro. Funciona perfeitamente com componentes standalone. createComponent retorna um ComponentRef com .instance e .destroy(). Limpe chamando destroy() para evitar vazamentos.

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' }" />

Módulos com Lazy Loading

Módulos com lazy loading criam um chunk JS separado, carregado na navegação. O import() dinâmico deve ser uma string estática para o bundler dividir. Módulos lazy têm seu próprio injector raiz — serviços com providedIn em um módulo lazy não são singletons no app inteiro. Apps standalone modernos usam loadComponent/loadChildren com arquivos de rotas, o que é mais simples e granular.

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.