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:
- 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 |
cria um signal; seu valor é lido chamando-o como uma função: mySignal() | |
substitui o valor do signal | |
calcula o novo valor a partir do antigo (veja increment() acima) | |
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:
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).
- 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]):
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.
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:
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]:
- 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) |
Componente (classe + template) | |
Signals (signal(), computed()) | |
Componentes standalone | |
input() / output() (signals) | |
[@Injectable]({ providedIn: 'root' }) | |
inject() (ou sempre via construtor) | |
[HttpClient] (Observables RxJS) | |
[@if] / [@for] | |
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.