Skip to content

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:

<!-- Counter.vue -->
<script setup lang="ts">
import { ref } from 'vue';

const value = ref(0);

function increment(): void {
  value.value++;
}
</script>

<template>
  <p>Value: {{ value }}</p>
  <button @click="increment">+1</button>
</template>

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
ref(initialValue)
cria um estado local com um ÚNICO valor; lido/escrito por meio de [.value] em [<script>] (nunca em [<template>])
reactive(initialObject)
cria um estado local com VÁRIAS propriedades (um objeto); lido/escrito diretamente, SEM [.value], propriedade por propriedade
computed(() => ...)
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]
watch(source, callback)
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:

<!-- Parent.vue -->
<script setup lang="ts">
import Counter from './Counter.vue';
</script>

<template>
  <div>
    <Counter />
  </div>
</template>

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:

// my-composable.ts
import { inject, reactive, type InjectionKey } from 'vue';

interface MyStore {
  greet: () => string;
}

const MyStoreKey: InjectionKey<MyStore> = Symbol('MyStore');

export function createMyStore(): MyStore {
  return reactive<MyStore>({
    greet: () => 'Hello',
  });
}

export function useMyStore(): MyStore {
  const store = inject(MyStoreKey);
  if (!store) {
    throw new Error('useMyStore() must be called after app.provide(MyStoreKey, ...)');
  }
  return store;
}

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

1
2
3
const httpResponse = await fetch('http://localhost:8080/hello');
const response = (await httpResponse.json()) as { message: string };
console.log(response.message);

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]):

1
2
3
4
5
6
<p v-if="loggedInUser">Welcome!</p>
<p v-else>Please log in.</p>

<ul>
  <li v-for="item in itemList" :key="item.id">{{ item.name }}</li>
</ul>

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)
Standalone components ([@Component]) / functional components ([React])
Componentes de arquivo único ([.vue])
Signals (signal(), input(), output(), computed()) / [useState](), props, [useMemo]() ([React])
[ref]()/[reactive](), [defineProps]/[defineEmits], [computed]()
effect() / [useEffect]() ([React])
[watch]()
Separate template (.html) + decorator (.ts) / embedded [JSX] (.tsx) ([React])
[<template>] + [<script setup>] combinados no mesmo arquivo [.vue]
[@if], [@for] / ternary operator, .map() ([React])
[v-if]/[v-else], [v-for]
Injectable services ([@Injectable]) + inject() / custom hooks + [Context] ([React])
Composables + [provide]/[inject]
[HttpClient] (RxJS Observables) / [fetch] (Promises) ([React])
[fetch] (Promises nativas, como no [React])
[@angular/router] (empty routing table) / No router ([React])
Sem roteador (mesma conclusão, levada um passo adiante)
Angular CLI / [@angular/build] / [Vite] ([React])
[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.