5. Capítulo 4 - Introdução ao [Vue.js]
5.1. Fontes
Este capítulo se baseia na documentação oficial do [Vue.js]: vuejs.org, e em particular em seu guia (vuejs.org/guide/introduction.html).
5.2. Do AngularJS 1.x ao [Vue.js]
O documento original (2014) usava o AngularJS 1.x: um framework (ainda sem TypeScript) organizado em torno de $scope, controllers, diretivas (ng-repeat, ng-if…) e um mecanismo de detecção de mudanças baseado no “ciclo de digestão” ($digest) e no monitoramento de variáveis ($watch).
[Vue.js] (criado por Evan You em 2014, após uma experiência no Google trabalhando com AngularJS) é, como o [Angular], um framework completo: ao contrário do [React] (uma simples biblioteca de interface), ele fornece seu próprio sistema de componentes, gerenciamento de estado reativo e — por meio de seus pacotes oficiais separados, que não são usados neste documento — um roteador ([vue-router]) e um gerenciador de estado global ([Pinia]). [Vue.js] descreve-se como “progressivo”: um núcleo focado na camada de view (semelhante, em conceito, ao $scope/template do AngularJS 1.x), complementado por seu próprio formato de componente — os arquivos [.vue] (veja abaixo). Este capítulo apresenta esses conceitos um a um, com exemplos curtos independentes do estudo de caso — o capítulo seguinte explorará sua aplicação no cliente [RdvMedecins] completo, em [Vue.js] 3.
5.3. O conceito por trás de uma aplicação [Vue.js]: a “Single Page Application”
Uma aplicação [Vue.js] é, como uma aplicação [Angular] ou [React], uma aplicação de página única (SPA): 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. Depois que essa página é carregada, nunca há outro recarregamento completo da página: cada interação do usuário (troca de views, 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 usando JSON). Esse já era o princípio do documento original com AngularJS 1.x, bem como das variantes [Angular] e [React] deste curso — isso não mudou: apenas o framework que cuida da exibição difere de uma variante para outra.
5.4. Os componentes: arquivos [.vue] e [Composition API]
Como no [Angular] e no [React], um componente é a unidade básica de uma aplicação [Vue.js]: ele gera o que deve ser exibido na tela com base em seu estado atual e nas propriedades que recebe. A diferença está na forma: um componente [Angular] é uma classe decorada, associada a um template HTML separado (ou inline); um componente [React] é uma função que retorna [JSX]; um componente [Vue.js] é um arquivo “single-file” [.vue], que combina três blocos distintos em um único arquivo: um [<template>] (o HTML, semelhante ao do [Angular]), um [<script setup>] (a lógica, como em TypeScript) e, opcionalmente, um [<style>] (os estilos específicos deste componente).
Eis um componente bem pequeno, independente do estudo de caso, equivalente a [CounterComponent] ([Angular]) e a [Counter.tsx] ([React]), que já foram apresentados neste curso:
Vamos detalhar este código:
- Linha 3: [import { ref } from 'vue';] — [ref] é a função do [Vue.js], que cria um valor reativo: um papel comparável ao de um signal no lado do [Angular], ou ao de [useState] no lado do [React];
- Linha 5: [const value = ref(0);] — [ref(0)] cria uma “caixa” reativa inicializada com 0. Ao contrário de [useState]() ([React]), que retorna um PAR (o valor e um setter), [ref()] retorna um ÚNICO objeto, cujo valor é lido e escrito por meio de sua propriedade [.value] — um mecanismo mais parecido, em conceito, com um [signal()] [Angular] (que é lido usando [mySignal()] e escrito usando [mySignal.set(...)]) do que com um par [value, setValue];
- linha 8: [value.value++;] — modificar [.value] atualiza o valor E redesenha automaticamente tudo o que depende dele em [<template>] - exatamente como com [mySignal.update(v => v + 1)] no [Angular]; ao contrário do [React] (em que os valores de estado são imutáveis), nada aqui impede que [.value] seja incrementado diretamente (++), sem passar por uma função de atualização separada;
- linhas 12–13: [Value: {{ value }}] — [<template>] É o template, assim como o HTML é separado no [Angular] - ao contrário do [JSX] e do [React], que derivam do JavaScript e se misturam ao código da função do componente. As chaves duplas [{{ }}] inserem ali uma expressão — o mesmo papel de [{{ value() }}] no [Angular] ([Vue.js] NÃO exige parênteses de chamada ([value], e não [value()]): em um [<template>], um [ref] é automaticamente “desempacotado”; nunca é preciso escrever [.value]).
5.5. O estado local: [ref]/[reactive] e as props
No AngularJS 1.x, o [Angular] detectava que um dado havia mudado por meio de um ciclo de verificação sistemático ($digest), que foi substituído, na variante [Angular] deste curso, pelos signals (signal(), computed()). [React] adota uma abordagem diferente: um componente reexecuta toda a sua função a cada mudança de estado. [Vue.js] adota uma terceira abordagem, híbrida: como o [Angular], rastreia com precisão os valores reativos que um componente usa (graças ao [<template>] compilado e ao sistema de “proxy” de [ref]/[reactive]) e atualiza apenas as partes do DOM que realmente dependem deles — sem nunca reexecutar todo o [<script setup>], e sem o custo do DOM virtual usado pelo [React] para chegar a um resultado comparável.
Função | Papel |
cria um estado local com um ÚNICO valor; lido/escrito por meio de [.value] em [<script>] (nunca em [<template>]) | |
cria um estado local com VÁRIAS propriedades (um objeto); lido/escrito diretamente, SEM [.value], propriedade por propriedade | |
deriva um valor de outros [ref]/[reactive], que é recalculado automaticamente apenas quando suas dependências mudam — o equivalente direto de [computed()] no lado do [Angular] e de [useMemo]() no lado do [React] | |
reexecuta [callback] sempre que [source] muda — o equivalente de [useEffect](..., [dep]) no lado do [React], ou de [effect()] no lado do [Angular] |
Dois mecanismos complementam [ref]/[reactive] para permitir que um componente se comunique com seu pai — eles são encontrados de forma consistente no cliente [RdvMedecins] (próximo capítulo), exatamente onde ficavam [input()]/[output()] no lado do [Angular], e as props/callback props no lado do [React]:
- as props ([defineProps<...>()]): um componente [Vue.js] declara o formato de suas entradas usando [defineProps], uma função especial reconhecida pelo compilador (que não exige nenhum [import]) - o equivalente direto de [input.required<Doctor[]>()] no lado do [Angular] e de um objeto de props desestruturado no lado do [React];
- eventos ([defineEmits<...>()]): em vez de uma simples função passada como prop (a escolha do [React]), o [Vue.js] distingue explicitamente os eventos que um componente emite — a função [emit(‘eventName’, value)] que ele retorna é o equivalente direto de [search.emit(value)] no lado do [Angular] ([output<...>()]).
5.6. Sem módulos: cada arquivo já é autocontido
Uma aplicação AngularJS 1.x era organizada em módulos (angular.module(...)). [Angular] adotou primeiro essa ideia de uma forma mais rígida (os arquivos NgModule), antes de propor componentes standalone como modo padrão. Como o [React], o [Vue.js] nunca precisou desse conceito: um arquivo [.vue] exporta implicitamente seu componente (o [<script setup>] É a exportação padrão do arquivo, sem precisar sequer especificar a palavra-chave [export]), e outro arquivo o utiliza com um simples [import] — os módulos ECMAScript padrão, sem nenhuma camada adicional específica do framework:
Este é o estilo usado em todo o cliente [RdvMedecins] (próximo capítulo): nenhum arquivo *.module.ts, nenhum decorador [imports: [...]] a manter — uma simplificação idêntica à que já vimos com o [React], em comparação com o AngularJS 1.x e o [Angular] com NgModule.
5.7. Lógica compartilhada: composables e [provide]/[inject]
Como no [NestJS] (Capítulo 2), o cliente [RdvMedecins] exige lógica compartilhada entre vários componentes: comunicação com o servidor, identificação do usuário conectado e troca de idioma. O [Angular] atende a essa necessidade com serviços injetáveis ([@Injectable]({ providedIn: ‘root’ }) + inject(...)); o [React] combina hooks personalizados com [Context]. [Vue.js] usa uma combinação semelhante à do [React], mas com vocabulário e mecanismo próprios:
- um composable — uma função cujo nome, por convenção, começa com [use] (como um hook do [React]), que pode, ela mesma, chamar outras funções do [Vue.js] ([ref], [inject]…) — encapsula lógica reutilizável, exatamente como um método de serviço do lado do servidor no [Angular];
- o par [provide]/[inject] compartilha um valor (estado + funções) com TODA a subárvore de componentes, sem ter de repassá-lo manualmente, propriedade por propriedade, por cada nível intermediário — o papel desempenhado por [providedIn: ‘root’] no lado do [Angular] e por [Context] no lado do [React]. Ao contrário do [React], que exige que um componente [Provider] seja visualmente ANINHADO na árvore em torno do componente raiz, o [Vue.js] fornece um valor com uma única chamada de função, [app.provide(key, value)], na instância da aplicação (veja main.ts, próximo capítulo) — sem nenhum aninhamento de componentes.
Eis um pequeno exemplo, independente do estudo de caso, conceitualmente equivalente a [MyService] ([Angular]) e a [my-context.tsx] ([React]), que já foram apresentados neste curso:
Vamos detalhar este código:
- Linha 8: [const MyStoreKey: InjectionKey<MyStore> = Symbol('MyStore');] — a chave de injeção: um [Symbol] em vez de uma simples string, para evitar qualquer colisão acidental com outra chave de mesmo nome - [InjectionKey<T>] é simplesmente um alias de [Symbol] no lado dos tipos, o que permite a [inject()] determinar automaticamente o tipo do valor retornado;
- Linha 10: [export function createMyStore(): MyStore {] — a fábrica, chamada APENAS UMA VEZ (em [main.ts]; veja o próximo capítulo), ANTES de existir qualquer componente — razão pela qual ela recebe suas eventuais dependências como parâmetros comuns da função, e não por meio de [inject()];
- linha 11: [return reactive<MyStore>({] — [reactive(...)] envolve o objeto em um proxy JavaScript: qualquer leitura de uma de suas propriedades em um [<template>] registra automaticamente uma dependência; qualquer operação de escrita redesenha tudo o que depende dela — ao contrário de [ref()], a propriedade ([store.greet]) é lida e escrita diretamente, sem [.value];
- Linhas 16–22: [export function useMyStore(): MyStore { …] — o composable que os componentes chamam ([const my = useMyStore();]), assim como teriam chamado [inject(MyService)] no [Angular], ou [useMyContext()] no [React]; o erro lançado se [inject(MyStoreKey)] retornar [undefined] indica uma omissão de ligação (o [app.provide(...)] correspondente não foi chamado) - exatamente a mesma rede de segurança do lado do [React] (o Context é null por padrão).
5.8. Comunicação com o servidor: [fetch]
[HttpClient] ([Angular]) foi o sucessor direto do serviço $http do AngularJS 1.x, usado pelo documento original. Como o [React], o [Vue.js] é apenas um framework de interface e, em seu núcleo, não fornece nenhum cliente HTTP: o cliente [RdvMedecins] usa diretamente [fetch], a API padrão do navegador (disponível sem nenhuma dependência adicional):
Uma diferença importante em relação ao $http e ao [HttpClient]: [fetch] retorna diretamente uma Promise (o mecanismo assíncrono padrão do JavaScript), e não um Observable — sem biblioteca RxJS, sem [.subscribe]({ next, error }), sem [.pipe(map(...))]. Ele pode ser usado com [.then(...)] ou, para maior legibilidade, com async/await (como mostrado acima). Um erro de rede ou uma resposta de erro é então tratado com um simples bloco try/catch, em vez de com o ramo de erro de uma assinatura RxJS — exatamente como no lado do [React].
O composable [useAppointmentService()] do cliente [RdvMedecins] (próximo capítulo) encapsula sistematicamente essa chamada a [fetch] seguida de [.json()], por um motivo específico explicado naquele ponto (o encapsulamento [ServerResponse]<T> comum a todas as respostas do servidor).
5.9. Renderização condicional e listas: [v-if]/[v-else] e [v-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. A variante [Angular] deste curso usa a sintaxe nativa [@if]/[@for]; o cliente [React] expressa a mesma coisa usando o operador ternário e [.map(...)], em JavaScript puro. O [Vue.js] está, neste ponto específico, mais próximo do [Angular]: seu [<template>] tem uma “linguagem” própria de diretivas, muito semelhante em espírito à do AngularJS 1.x (ng-if torna-se [v-if], ng-repeat torna-se [v-for]):
Vamos detalhar este código:
- linhas 1–2: [v-if="loggedInUser" … v-else …] — [v-if]/[v-else] substituem [@if]/[@else] ([Angular]) e ng-if (AngularJS 1.x): somente o ramo cuja condição é verdadeira é MONTADO no DOM — exatamente o mesmo comportamento do operador ternário do [React] ({ condition ? ... : ... }), mas expresso como um atributo HTML, e não como uma expressão JavaScript aninhada dentro do [JSX];
- Linha 5: [v-for="item in itemList" :key="item.id"] — [v-for] substitui [@for] ([Angular]) e ng-repeat (AngularJS 1.x), e serve exatamente ao mesmo propósito que [.map(...)] no lado do [React]: repete o elemento para cada entrada do array. [:key] (obrigatório, assim como [key={item.id}] no [React] e track no [Angular]) informa ao [Vue.js] como reconhecer um elemento já exibido quando ele redesenha a lista.
5.10. Resumo: correspondências [Angular] -> [React] -> [Vue.js]
[Angular]/[React] (versões anteriores deste curso) | [Vue.js] (2026) |
Componentes de arquivo único ([.vue]) | |
[ref]()/[reactive](), [defineProps]/[defineEmits], [computed]() | |
[watch]() | |
[<template>] + [<script setup>] combinados no mesmo arquivo [.vue] | |
[v-if]/[v-else], [v-for] | |
Composables + [provide]/[inject] | |
[fetch] (Promises nativas, como no [React]) | |
Sem roteador (mesma conclusão, levada um passo adiante) | |
[Vite] (com [@vitejs/plugin-vue] em vez de [@vitejs/plugin-react]) |
Esses conceitos bastam para abordar o cliente [RdvMedecins] no próximo capítulo: cada novo uso será, no entanto, explicado novamente ali, à medida que o código avança, no ponto exato em que aparecer.