5. Estado compartilhado
Em uma aplicação, certos dados interessam a muitos componentes: o usuário logado, o carrinho de compras etc. O Exemplo 11 compartilhava esses dados com [provide] / [inject], enquanto o Exemplo 14 usava um módulo com [ref] . [Pinia], a biblioteca oficial do [Vue.js] para estado compartilhado, organiza isso em stores e as torna visíveis na extensão [Vue.js devtools].
Ela é instalada em [main.ts]:
| // =========================================================================
// 15-pinia/src/main.ts
// -------------------------------------------------------------------------
// app.use(createPinia()): o Pinia é instalado, a biblioteca oficial do Vue.js
// para o gerenciamento de estado COMPARTILHADO. Os "stores" definidos
// a seguir são acessíveis de qualquer componente.
// =========================================================================
import { createApp } from 'vue';
import { createPinia } from 'pinia';
import 'bootstrap/dist/css/bootstrap.min.css';
import App from './App.vue';
createApp(App).use(createPinia()).mount('#app');
|
A primeira store, o carrinho de compras:
| // =========================================================================
// 15-pinia/src/stores/cart.ts - um STORE do Pinia
// -------------------------------------------------------------------------
// defineStore('cart', () => { ... }): um store escrito como um composable
// (estilo "setup"):
// - os refs são o ESTADO do store;
// - os valores computed, seus GETTERS (valores calculados);
// - as funções, suas ACTIONS (o que modifica o estado).
// Diferença em relação a um composable (exemplo 11): o store existe em apenas UMA
// cópia para toda a aplicação. Todos os componentes que chamam
// useCartStore() recebem o MESMO carrinho. Ele vive enquanto a aplicação
// viver: sobrevive à remoção de um componente... mas não ao recarregamento
// da página (F5), que reinicia a aplicação.
// =========================================================================
import { computed, ref } from 'vue';
import { defineStore } from 'pinia';
export interface Item {
label: string;
price: number;
}
export const useCartStore = defineStore('cart', () => {
const items = ref<Item[]>([]);
const count = computed(() => items.value.length);
const total = computed(() => items.value.reduce((s, a) => s + a.price, 0));
function add(item: Item): void {
items.value.push(item);
}
function clear(): void {
items.value = [];
}
// tudo o que é retornado faz parte do store
return { items, count, total, add, clear };
});
|
- linhas 24–39: [defineStore(name, function)] define uma store no estilo “setup”, como um composable: os [ref] são seu estado, os [computed] são seus getters, e as funções são suas ações; ela expõe o que a função retorna;
- A diferença em relação a um composable: há apenas uma instância da store para toda a aplicação. Todos os componentes que chamam [useCartStore()] recebem o MESMO carrinho de compras. Ela vive enquanto a aplicação viver: sobrevive à remoção de um componente... mas não ao recarregamento da página (F5), que reinicia a aplicação.
Uma segunda store, porém, sobrevive ao recarregamento da página:
| // =========================================================================
// 15-pinia/src/stores/preferences.ts - um store que sobrevive ao F5
// -------------------------------------------------------------------------
// Para que um dado sobreviva ao recarregamento da página, ou ao fechamento
// do navegador, ele deve ser armazenado NO navegador: localStorage (um
// pequeno dicionário chave -> string, específico de cada site).
// - na inicialização, o store lê o localStorage novamente;
// - watch(..., { deep: true }) reescreve o localStorage a cada mudança.
// NUNCA armazene dados sensíveis ali (senha, token): qualquer script
// da página pode ler o localStorage.
// =========================================================================
import { ref, watch } from 'vue';
import { defineStore } from 'pinia';
const KEY = 'example15.preferences';
interface Preferences {
dark: boolean;
size: number; // tamanho do texto, em px
}
function read(): Preferences {
try {
return { dark: false, size: 16, ...JSON.parse(localStorage.getItem(KEY) ?? '{}') };
} catch {
return { dark: false, size: 16 }; // conteúdo ilegível: valores padrão
}
}
export const usePreferencesStore = defineStore('preferences', () => {
const preferences = ref<Preferences>(read());
watch(preferences, (p) => localStorage.setItem(KEY, JSON.stringify(p)), { deep: true });
return { preferences };
});
|
- Linhas 23–29: na inicialização, o navegador relê o [localStorage], um pequeno dicionário chave/valor que o navegador armazena para cada site, mesmo depois de fechado. Se o conteúdo for ilegível, os valores padrão são usados;
- Linha 34: [{ deep: true }]: o [watch] também reage às mudanças nas propriedades do objeto. Cada mudança é regravada no [localStorage].
NUNCA armazene dados sensíveis (senhas, tokens) no [localStorage]: qualquer script executado na página pode ler o [localStorage].
Os componentes:
| <!-- 15-pinia/src/components/Shop.vue - ADICIONA ao carrinho compartilhado -->
<script setup lang="ts">
import { useCartStore, type Item } from '../stores/cart';
const cart = useCartStore();
const products: Item[] = [
{ label: 'Consultation', price: 30 },
{ label: 'Vaccine', price: 12.5 },
];
</script>
<template>
<div class="card p-3 h-100">
<h2 class="h6">Shop</h2>
<button v-for="p in products" :key="p.label" class="btn btn-sm btn-outline-primary mb-2" @click="cart.add(p)">
+ {{ p.label }} (€{{ p.price }})
</button>
</div>
</template>
|
- Linha 5: a store é usada como um objeto reativo: [cart.add(p)];
| <!--
15-pinia/src/components/CartSummary.vue - READS the same cart
storeToRefs: to DESTRUCTURE a store without losing reactivity
(const { count } = cart would give a simple, frozen copy).
-->
<script setup lang="ts">
import { storeToRefs } from 'pinia';
import { useCartStore } from '../stores/cart';
const cart = useCartStore();
const { count, total } = storeToRefs(cart);
</script>
<template>
<div class="card p-3 h-100">
<h2 class="h6">Cart</h2>
<p class="mb-2">{{ count }} item(s), €{{ total }}</p>
<!-- as actions, por sua vez, podem ser desestruturadas ou chamadas diretamente -->
<button class="btn btn-sm btn-outline-danger align-self-start" :disabled="count === 0" @click="cart.clear()">Clear</button>
</div>
</template>
|
- linha 11: para desestruturar uma store sem perder a reatividade. [const { count } = cart] retornaria uma simples cópia, congelada no valor atual; [storeToRefs] retorna instâncias de [ref] ligadas à store. As ações, por outro lado, podem ser desestruturadas ou chamadas diretamente.
| <!-- 15-pinia/src/components/LocalCounter.vue - um estado LOCAL, que desaparece com o componente -->
<script setup lang="ts">
import { ref } from 'vue';
const clicks = ref(0);
</script>
<template>
<div class="card p-3 h-100">
<h2 class="h6">Local state</h2>
<button class="btn btn-sm btn-outline-secondary align-self-start" @click="clicks++">{{ clicks }} click(s)</button>
</div>
</template>
|
| <!--
=========================================================================
15-pinia/src/App.vue - three "scopes" of data on the client side
-------------------------------------------------------------------------
Same question as example 23 of the NestJS course (application,
request, client scope), transposed to the browser:
- the LOCAL state of a component (LocalCounter) disappears with it;
- the state of a STORE (the cart) is shared by all the components and
survives their removal - but not F5;
- the state stored in localStorage (the preferences) survives F5 and the
closing of the browser.
Uncheck then check the box again, then reload the page: compare.
=========================================================================
-->
<script setup lang="ts">
import { ref } from 'vue';
import { usePreferencesStore } from './stores/preferences';
import Shop from './components/Shop.vue';
import CartSummary from './components/CartSummary.vue';
import LocalCounter from './components/LocalCounter.vue';
const prefs = usePreferencesStore();
const areaVisible = ref(true);
</script>
<template>
<div :class="{ 'bg-dark text-light': prefs.preferences.dark }" :style="{ fontSize: prefs.preferences.size + 'px' }" class="min-vh-100">
<div class="container py-4">
<h1 class="h3 mb-3">Example 15 - a shared state with Pinia</h1>
<div class="d-flex flex-wrap gap-4 mb-3">
<label class="form-check-label"><input v-model="prefs.preferences.dark" type="checkbox" class="form-check-input"> dark theme</label>
<label>text size <input v-model.number="prefs.preferences.size" type="range" min="12" max="22"> {{ prefs.preferences.size }} px</label>
<label class="form-check-label"><input v-model="areaVisible" type="checkbox" class="form-check-input"> show the area</label>
</div>
<div v-if="areaVisible" class="row g-3 text-body">
<div class="col-md-4"><Shop /></div>
<div class="col-md-4"><CartSummary /></div>
<div class="col-md-4"><LocalCounter /></div>
</div>
<p class="mt-3 mb-2">Outside the area, a second summary of the SAME cart (it stays there when the area disappears):</p>
<div class="text-body"><CartSummary /></div>
</div>
</div>
</template>
|
- Linha 35: desmarcar “mostrar a área” remove os três componentes da página;
- linha 41: um segundo resumo do mesmo carrinho de compras, fora da área.
Mesma pergunta do Exemplo 23 do curso [NestJS] (escopos de aplicação, de requisição e de cliente), adaptada para o navegador:
Dado | Onde? | Duração |
O contador de LocalCounter | o estado local do componente | desaparece junto com o componente |
o carrinho de compras | uma store Pinia | toda a aplicação, até o F5 |
as preferências | uma store Pinia + localStorage | sobrevive ao F5 e ao fechamento do navegador |
Dois itens adicionados e dois cliques:

A seção foi removida e o tema escuro foi selecionado: o carrinho de compras continua lá; se a seção for exibida novamente, o contador local volta a zero:
