Skip to content

5. Capítulo 4 - Introdução ao [Angular]

5.1. Fontes

Este capítulo baseia-se na documentação oficial do [Angular]: angular.dev.

5.2. Do AngularJS 1.x ao [Angular]

O documento original (2014) usava o AngularJS 1.x: um framework (JavaScript — ainda não TypeScript) organizado em torno de $scope, controllers, diretivas (ng-repeat, ng-if…) e de um mecanismo de detecção de mudanças baseado no “loop de digestão” ($digest) e no monitoramento de variáveis ($watch).

A partir de 2016, esse framework foi completamente reescrito com o nome de [Angular] (sem o “JS”), em TypeScript, com uma arquitetura baseada em componentes. Versões subsequentes se sucederam (2, 4… até a 22, usada neste documento), com duas grandes mudanças que você deve conhecer antes de trabalhar com o código do cliente [RdvMedecins]:

  • o abandono gradual dos NgModules (@NgModule) em favor de componentes standalone, autossuficientes;
  • a introdução dos signals (signal()), um novo modelo de reatividade que substitui $watch/$digest.

Este capítulo apresenta esses conceitos um a um, com exemplos curtos independentes do estudo de caso — o próximo capítulo os demonstrará em ação no cliente [RdvMedecins] completo.

5.3. O conceito de aplicação [Angular]: a “Single Page Application”

Uma aplicação [Angular] é uma aplicação de página única (SPA, Single Page Application): o servidor entrega ao navegador apenas uma única página (HTML), contendo um único arquivo JavaScript que incorpora toda a lógica da aplicação. Uma vez carregada essa página, nunca há outro recarregamento completo: cada interação do usuário (mudança de view, envio de um formulário etc.) é tratada pelo código JavaScript já presente no navegador, que atualiza a exibição e se comunica com o servidor em segundo plano por meio de requisições HTTP assíncronas (na maioria das vezes em JSON). Esse já era o princípio do documento original com AngularJS 1.x — nada mudou.

5.4. Componentes

Um componente é a unidade básica de uma aplicação [Angular]: ele associa uma view (um template HTML) a uma classe TypeScript que gerencia seu estado e seu comportamento — exatamente o papel desempenhado, no documento original, pelo par “view + controller” do AngularJS 1.x, mas aqui reunidos em uma única entidade.

Eis um componente bem pequeno, independente do estudo de caso, que poderia ser criado com ng generate component counter:

// counter.component.ts
import { Component, signal } from '@angular/core';

@Component({
  selector: 'app-counter',
  templateUrl: './counter.component.html',
})
export class CounterComponent {
  readonly value = signal(0);

  increment(): void {
    this.value.update((v) => v + 1);
  }
}
<!-- counter.component.html -->
<p>Value: {{ value() }}</p>
<button (click)="increment()">+1</button>
  • linha 4: [@Component]({...}) é um decorador (mesmo mecanismo do [NestJS]; veja o Capítulo 2) que declara a classe seguinte como um componente [Angular];
  • linha 5: selector: 'app-counter': o nome da tag HTML personalizada (<app-counter>) que, quando usada no template de outro componente, insere esse componente nesse local — o mecanismo de composição de views, já presente (de outra forma, as diretivas) no AngularJS 1.x;
  • linha 6: templateUrl: o arquivo HTML associado a este componente (também é possível escrever o HTML diretamente no decorador, usando a propriedade template);
  • linha 9: signal(0) cria um valor reativo inicializado com 0 (veja a próxima seção);
  • linha 16: {{ value() }} no template: as chaves duplas exibem um valor calculado pela classe — sintaxe idêntica à do AngularJS 1.x, mas observe os parênteses: `value` é um signal e, portanto, uma função que deve ser chamada para ler seu valor atual;
  • linha 17: (click)="increment()": os parênteses em torno de `click` significam “escutar o evento `DOM` click” e chamar o método especificado — o equivalente exato da diretiva `ng-click` do `AngularJS` 1.x.

5.5. Signals: o novo modelo de reatividade

No AngularJS 1.x, o [Angular] detectava mudanças nos dados por meio de um loop de verificação sistemático (o $digest), que percorria todas as expressões monitoradas ($watch) a cada interação possível. Esse mecanismo, embora simples de usar, tornava-se custoso à medida que a aplicação crescia.

Um signal é um contêiner de valor que sabe quando muda e sabe o que depende dele (um template, outro cálculo etc.) — assim, o [Angular] não precisa mais reverificar tudo: apenas as partes da aplicação que realmente dependem de um signal modificado são recalculadas. Três funções bastam para entender o básico:

Função
Finalidade
mySignal(initialValue)
cria um signal; seu valor é lido chamando-o como uma função: mySignal()
mySignal.set(newValue)
substitui o valor do signal
mySignal.update(v => ...)
calcula o novo valor a partir do antigo (veja increment() acima)
computed(() => ...)
cria um signal calculado automaticamente a partir de outros signals e recalculado somente quando necessário

Duas variantes especializadas de signal() são usadas para permitir que um componente se comunique com seu pai — elas aparecem com frequência no cliente [RdvMedecins] (veja o próximo capítulo):

  • input() (e sua variante input.required()) declara uma entrada: um valor fornecido pelo componente pai. É a evolução moderna do tradicional decorador @Input() e o equivalente conceitual de um atributo de diretiva do AngularJS 1.x;
  • output() declara uma saída: um evento que o componente pode emitir para seu pai (por meio do método .emit(value)). É a evolução moderna de @Output() / EventEmitter e o equivalente dos eventos personalizados ($emit) do AngularJS 1.x.

5.6. Componentes standalone

Uma aplicação AngularJS 1.x era organizada em módulos (angular.module(...)), que declaravam controllers, diretivas e serviços. O [Angular] adotou inicialmente essa ideia de forma mais rígida (o NgModule, decorador @NgModule), antes de introduzir, nas versões recentes, os componentes standalone — que desde então se tornaram o modo de operação padrão.

Um componente standalone declara tudo de que precisa — como os outros componentes que usa em seu template — dentro do seu próprio decorador [@Component], em vez de depender de um módulo compartilhado:

1
2
3
4
5
6
@Component({
  selector: 'app-parent',
  imports: [CounterComponent], // os componentes usados no template
  templateUrl: './parent.component.html',
})
export class ParentComponent {}

Este é o estilo usado em todo o cliente [RdvMedecins] (veja o próximo capítulo): nenhum arquivo *.module.ts aparece ali, uma simplificação significativa tanto em relação ao AngularJS 1.x quanto às versões anteriores do Angular.

5.7. Serviços e injeção de dependência

Como no [NestJS] (Capítulo 2), um serviço do [Angular] é uma classe comum, decorada por [@Injectable], que o [Angular] pode criar automaticamente e fornecer a qualquer componente que precise dela - o mesmo conceito de injeção de dependência, cujo princípio o AngularJS 1.x foi, aliás, um dos primeiros frameworks JavaScript a popularizar (não é por acaso que o [NestJS] se inspirou diretamente nele, como observado no Capítulo 2).

1
2
3
4
5
6
7
8
import { Injectable } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class MyService {
  greet(): string {
    return 'Hello';
  }
}
  • Linha 3: providedIn: 'root' indica que uma única instância deste serviço é criada para toda a aplicação (um singleton) — o equivalente ao que era um .service() ou um .factory() no AngularJS 1.x.

Para obter este serviço em um componente, o [Angular] moderno oferece a função inject(), que substitui a antiga injeção pelo construtor (ambas ainda funcionam, mas inject() tornou-se a prática padrão e é a usada pelo cliente [RdvMedecins]):

1
2
3
4
5
6
7
import { Component, inject } from '@angular/core';
import { MyService } from './my.service';

@Component({ ... })
export class MyComponent {
  private readonly myService = inject(MyService);
}

5.8. Comunicação com o servidor: [HttpClient]

O módulo [HttpClient] ([@angular/common/http]) permite enviar requisições HTTP - GET, POST… - a um servidor e processar sua resposta. É uma evolução direta do serviço $http do AngularJS 1.x usado pelo documento original.

1
2
3
4
5
6
7
8
import { inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';

const http = inject(HttpClient);
http.get<{ message: string }>('http://localhost:8080/hello').subscribe({
  next: (response) => console.log(response.message),
  error: (error) => console.error(error),
});

Uma diferença importante em relação ao $http: os métodos do [HttpClient] (get, post…) não retornam diretamente a resposta, nem uma Promise como se poderia esperar, mas um Observable (biblioteca RxJS) — um fluxo de valores ao longo do tempo, no qual você se inscreve com .subscribe({ next, error }) para ser notificado quando a resposta chegar (ou quando ocorrer um erro). Também é possível transformar um Observable antes de se inscrever nele, usando operadores como map:

1
2
3
http.get<{ message: string }>('...').pipe(
  map((response) => response.message), // we only keep the "message" field
);

O serviço [AppointmentService] do cliente [RdvMedecins] (próximo capítulo) usa de forma consistente essa combinação .pipe(map(...)), por um motivo específico explicado ali.

5.9. A nova sintaxe de controle de fluxo: [@if] e [@for]

O AngularJS 1.x usava diretivas estruturais (ng-if, ng-repeat) para exibir um elemento condicionalmente ou repetir um bloco de template para cada elemento de uma lista. O [Angular] usou por muito tempo um equivalente muito semelhante (*ngIf, *ngFor), antes de introduzir, em suas versões recentes, uma sintaxe integrada à própria linguagem de template — a usada em todo o cliente [RdvMedecins]:

@if (loggedInUser()) {
  <p>Welcome!</p>
} @else {
  <p>Please log in.</p>
}

<ul>
  @for (item of itemList(); track item.id) {
    <li>{{ item.name }}</li>
  }
</ul>
  • linha 8: track item.[id] (obrigatório com [@for]) informa ao [Angular] como reconhecer um elemento já exibido quando ele redesenha a lista — da mesma forma que o “track by” já era possível, como opção, com ng-repeat.

5.10. Resumo: correspondências AngularJS 1.x -> [Angular]

AngularJS 1.x (2014)
[Angular] (2026)
Controller + $scope
Componente (classe + template)
$watch / $digest loop
Signals (signal(), computed())
angular.module(...), @NgModule
Componentes standalone
@Input() / @Output() (legacy)
input() / output() (signals)
.service() / .factory()
[@Injectable]({ providedIn: 'root' })
Constructor injection
inject() (ou sempre via construtor)
$http
[HttpClient] (Observables RxJS)
ng-if / ng-repeat
[@if] / [@for]
JavaScript
TypeScript

Esta base é suficiente para abordar o cliente [RdvMedecins] no próximo capítulo: cada novo recurso será, de qualquer forma, explicado novamente ali, à medida que o código avança, no ponto exato em que aparece.