Kurs Vue.js · Moduł 9: Composables i VueUse
Reaktywne wzorce projektowe
W tej lekcji4
W centrum kontroli NOVA LAB każdy system musi być niezawodny i przewidywalny. Problem pojawia się, gdy moduły muszą ze sobą współpracować: panel motywu i panel powiadomień powinny widzieć te same dane, czujnik ma zaalarmować kilka systemów naraz, a eksperyment nie może przeskoczyć z "przerwany" prosto do "zakończony". Wzorce projektowe z reaktywnością Vue 3 pozwalają budować takie systemy - jak sprawdzone protokoły inżynieryjne stacji kosmicznej.
Reactive Singleton
Czasem potrzebujemy jednej wspólnej instancji stanu - jak centralny komputer stacji, z którego korzystają wszystkie moduły. Sztuczka polega na tym, gdzie powstaje stan: obiekt reactive tworzymy poza funkcją composable, na poziomie modułu JavaScript, więc istnieje dokładnie raz. Funkcja readonly zwraca jego wersję tylko do odczytu:
import { reactive, readonly } from 'vue'
// Stan tworzony RAZ, poza funkcją
const globalState = reactive({
currentUser: null,
theme: 'dark',
locale: 'pl',
notifications: []
})
// Composable zwraca ten sam stan za każdym razem
export function useGlobalStore() {
function setUser(user) {
globalState.currentUser = user
}
function setTheme(theme) {
globalState.theme = theme
}
function addNotification(msg) {
globalState.notifications.push({
id: Date.now(),
message: msg,
read: false
})
}
// readonly zapobiega bezpośredniej modyfikacji
return {
state: readonly(globalState),
setUser,
setTheme,
addNotification
}
}Zmiany przechodzą wyłącznie przez metody, a próba zapisu state.theme = 'light' w komponencie skończy się ostrzeżeniem w konsoli i wartość się nie zmieni. Użycie w dowolnym komponencie wygląda tak:
<!-- Dowolny komponent - ten sam stan -->
<script setup>
import { useGlobalStore } from './composables/useGlobalStore'
// Oba komponenty widzą te same dane
const { state, addNotification } = useGlobalStore()
</script>
<template>
<p>Motyw: {{ state.theme }}</p>
<p>Powiadomienia: {{ state.notifications.length }}</p>
</template>Kluczowa różnica: stan jest zdefiniowany poza funkcją composable, więc każde wywołanie useGlobalStore() zwraca referencję do tego samego obiektu. Jedno zastrzeżenie: przy renderowaniu na serwerze (SSR) taki stan byłby wspólny dla wszystkich użytkowników. Dlatego w dużych aplikacjach tę rolę przejmuje Pinia, którą poznasz w Bazie Danych Misji.
Event Bus z reaktywnością
Vue 3 usunął metody $on i $off z instancji komponentu, na których w Vue 2 budowano globalny event bus. Możemy jednak stworzyć reaktywny system zdarzeń - jak sieć komunikacyjna stacji NOVA LAB. Mapa listeners przypisuje nazwie zdarzenia listę funkcji obsługi, a ref lastEvent pamięta ostatni sygnał. Oba powstają poza funkcją, jak w singletonie, dzięki czemu wszystkie komponenty nadają w tej samej sieci:
import { ref } from 'vue'
// Jedna sieć dla całej aplikacji - poza funkcją
const lastEvent = ref(null)
const listeners = new Map()
function useEventBus() {
function emit(eventName, payload) {
lastEvent.value = { name: eventName, payload, timestamp: Date.now() }
const handlers = listeners.get(eventName) || []
handlers.forEach(handler => handler(payload))
}
function on(eventName, handler) {
if (!listeners.has(eventName)) {
listeners.set(eventName, [])
}
listeners.get(eventName).push(handler)
// Zwróć funkcję unsubscribe
return () => {
const handlers = listeners.get(eventName)
const index = handlers.indexOf(handler)
if (index > -1) handlers.splice(index, 1)
}
}
return { lastEvent, emit, on }
}Gdyby mapa powstawała w środku funkcji, każdy komponent miałby własną, prywatną sieć i sygnały z jednego modułu nie docierałyby do drugiego. Metoda on zwraca funkcję wypisującą obsługę z listy, a komponent musi ją wywołać przy odmontowaniu:
<script setup>
import { onUnmounted } from 'vue'
const { emit, on } = useEventBus()
// Subskrypcja z automatycznym cleanup
const unsubscribe = on('sensor-alert', (data) => {
console.log('Alert z sensora:', data)
})
onUnmounted(() => {
unsubscribe() // Ważne! Zapobiegamy wyciekom pamięci
})
// Emitowanie zdarzenia
emit('sensor-alert', { sensorId: 'T-01', value: 45 })
</script>Bez unsubscribe odmontowany komponent zostałby w mapie na zawsze i dalej reagował na alarmy - to klasyczny wyciek pamięci.
State Machine z ref i computed
Automaty stanowe to idealny wzorzec do zarządzania złożonym stanem - jak protokoły bezpieczeństwa stacji, gdzie każdy stan ma dokładnie określone przejścia. Automat trzyma bieżący stan w refie, a listę dozwolonych zdarzeń wylicza przez computed:
import { ref, computed } from 'vue'
function useStateMachine(config) {
const currentState = ref(config.initial)
const availableTransitions = computed(() => {
const stateConfig = config.states[currentState.value]
return stateConfig ? Object.keys(stateConfig.on || {}) : []
})
function transition(event) {
const stateConfig = config.states[currentState.value]
if (!stateConfig || !stateConfig.on || !stateConfig.on[event]) {
console.warn(
`Niedozwolone przejście: ${currentState.value} -> ${event}`
)
return false
}
const nextState = stateConfig.on[event]
currentState.value = nextState
return true
}
function canTransition(event) {
return availableTransitions.value.includes(event)
}
return { currentState, availableTransitions, transition, canTransition }
}Metoda transition odrzuca zdarzenie, którego bieżący stan nie przewiduje, i zwraca false zamiast psuć dane. Całą wiedzę o przejściach opisujemy w obiekcie konfiguracji, gdzie pole on każdego stanu mapuje zdarzenie na stan docelowy:
<script setup>
const experimentMachine = useStateMachine({
initial: 'idle',
states: {
idle: {
on: { START: 'running', CONFIGURE: 'configuring' }
},
configuring: {
on: { SAVE: 'idle', CANCEL: 'idle' }
},
running: {
on: { PAUSE: 'paused', COMPLETE: 'completed', FAIL: 'failed' }
},
paused: {
on: { RESUME: 'running', ABORT: 'failed' }
},
completed: {
on: { RESET: 'idle' }
},
failed: {
on: { RESET: 'idle', RETRY: 'running' }
}
}
})
// Używamy w template
// experimentMachine.currentState.value => 'idle'
// experimentMachine.transition('START') => stan zmienia się na 'running'
// experimentMachine.canTransition('PAUSE') => true (teraz jesteśmy w 'running')
</script>Ze stanu idle nie da się wywołać PAUSE, więc przycisk pauzy możesz wyłączyć zwykłym :disabled="!experimentMachine.canTransition('PAUSE')".
Reactive Observer Pattern
Wzorzec obserwatora z reaktywnością Vue - jak system monitorowania, gdzie każdy sensor może mieć wielu obserwatorów. Każdy subskrybent to osobny watch, a funkcja zwrócona przez watch zatrzymuje go na żądanie:
import { ref, watch, readonly } from 'vue'
function useObservable(initialValue) {
const value = ref(initialValue)
const history = ref([])
const observers = ref(0)
// Każdy watch to nowy obserwator
function subscribe(callback) {
observers.value++
const unwatch = watch(value, (newVal, oldVal) => {
callback({ newVal, oldVal, timestamp: Date.now() })
})
return () => {
unwatch()
observers.value--
}
}
function setValue(newValue) {
history.value.push({
from: value.value,
to: newValue,
timestamp: Date.now()
})
if (history.value.length > 100) history.value.shift()
value.value = newValue
}
return {
value: readonly(value),
history: readonly(history),
observers,
subscribe,
setValue
}
}Historia trzyma najwyżej 100 ostatnich zmian, a wartość i historię udostępniamy tylko do odczytu. W komponencie jest jedna pułapka: template automatycznie rozpakowuje tylko refy z najwyższego poziomu, a nie refy schowane w zwykłym obiekcie. Dlatego wyciągamy je destrukturyzacją:
<script setup>
import { onUnmounted } from 'vue'
const temperature = useObservable(22)
// Refy wyciągamy na najwyższy poziom, żeby template je rozpakował
const { value: currentTemp, history, observers } = temperature
// Obserwator 1 - alarm
const unsub1 = temperature.subscribe(({ newVal }) => {
if (newVal > 40) console.warn('Temperatura krytyczna!')
})
// Obserwator 2 - logowanie
const unsub2 = temperature.subscribe(({ newVal, oldVal }) => {
console.log(`Temp: ${oldVal} -> ${newVal}`)
})
onUnmounted(() => {
unsub1()
unsub2()
})
// Zmiana wartości powiadamia wszystkich obserwatorów
temperature.setValue(25)
</script>
<template>
<p>Temperatura: {{ currentTemp }}°C</p>
<p>Aktywni obserwatorzy: {{ observers }}</p>
<p>Historia zmian: {{ history.length }}</p>
</template>Panel pokaże 25°C, dwóch obserwatorów i jedną zmianę w historii, a konsola wypisze "Temp: 22 -> 25". Gdybyś napisał w szablonie temperature.history.length, zobaczyłbyś puste miejsce, bo zagnieżdżony ref nie zostałby rozpakowany.
Moja rada: zanim sięgniesz po event bus, sprawdź, czy wystarczą props i emity, provide/inject albo wspólny store. Dokumentacja Vue odradza globalny bus w większości sytuacji, bo przepływ danych staje się niewidoczny. VueUse, które poznasz w następnej lekcji, ma zresztą gotowe useEventBus. W edytorze poniżej singleton przełącza motyw, automat prowadzi eksperyment przez kolejne stany, a obserwowana temperatura powiadamia subskrybentów.
Zapamiętaj: dobry wzorzec to protokół stacji - mówi, kto może zmienić stan, kiedy i kogo trzeba o tym zawiadomić.
Kod do tej lekcji: App.vue
<script setup>
import { ref, computed, watch, readonly } from 'vue'
// ===== REAKTYWNY SINGLETON =====
const globalState = {
theme: ref('dark'),
locale: ref('pl'),
notifications: ref([])
}
function useGlobalStore() {
function setTheme(t) { globalState.theme.value = t }
function addNotification(msg) {
globalState.notifications.value.push({ id: Date.now(), message: msg })
}
return {
theme: globalState.theme,
locale: globalState.locale,
notifications: globalState.notifications,
setTheme,
addNotification
}
}
// ===== STATE MACHINE (maszyna stanów) =====
function useStateMachine(config) {
const currentState = ref(config.initial)
const availableTransitions = computed(() => {
const sc = config.states[currentState.value]
return sc ? Object.keys(sc.on || {}) : []
})
function transition(event) {
const sc = config.states[currentState.value]
if (!sc || !sc.on || !sc.on[event]) return false
currentState.value = sc.on[event]
return true
}
function canTransition(event) {
return availableTransitions.value.includes(event)
}
return { currentState, availableTransitions, transition, canTransition }
}
// ===== REAKTYWNY OBSERWATOR =====
function useObservable(initialValue) {
const value = ref(initialValue)
const history = ref([])
const observerCount = ref(0)
function subscribe(callback) {
observerCount.value++
const unwatch = watch(value, (newVal, oldVal) => {
callback({ newVal, oldVal })
})
return () => { unwatch(); observerCount.value-- }
}
function setValue(newValue) {
history.value.push({ from: value.value, to: newValue, time: new Date().toLocaleTimeString() })
if (history.value.length > 15) history.value.shift()
value.value = newValue
}
return { value, history, observerCount, subscribe, setValue }
}
// === Instancje ===
const store = useGlobalStore()
const experiment = useStateMachine({
initial: 'idle',
states: {
idle: { on: { START: 'running', CONFIGURE: 'configuring' } },
configuring: { on: { SAVE: 'idle', CANCEL: 'idle' } },
running: { on: { PAUSE: 'paused', COMPLETE: 'completed', FAIL: 'failed' } },
paused: { on: { RESUME: 'running', ABORT: 'failed' } },
completed: { on: { RESET: 'idle' } },
failed: { on: { RESET: 'idle', RETRY: 'running' } }
}
})
const temperature = useObservable(22)
// Subskrypcja obserwatorów
const alerts = ref([])
temperature.subscribe(({ newVal }) => {
if (newVal > 35) alerts.value.unshift('ALARM: temperatura ' + newVal + '°C!')
if (alerts.value.length > 5) alerts.value.pop()
})
temperature.subscribe(({ newVal, oldVal }) => {
store.addNotification('Temperatura: ' + oldVal + ' -> ' + newVal)
})
</script>
<template>
<div class="lab" :class="store.theme.value">
<h1>Wzorce reaktywne - NOVA LAB</h1>
<section>
<h2>Store jako singleton</h2>
<p>Motyw: {{ store.theme.value }} | Język: {{ store.locale.value }}</p>
<button @click="store.setTheme(store.theme.value === 'dark' ? 'light' : 'dark')">Przełącz motyw</button>
<div class="notifs">
<div v-for="n in store.notifications.value.slice(-5)" :key="n.id" class="notif">{{ n.message }}</div>
</div>
</section>
<section>
<h2>State Machine - eksperyment</h2>
<div class="state-display">{{ experiment.currentState.value.toUpperCase() }}</div>
<div class="transitions">
<button v-for="t in experiment.availableTransitions.value" :key="t"
@click="experiment.transition(t)" class="trans-btn">
{{ t }}
</button>
</div>
<p v-if="!experiment.availableTransitions.value.length" class="info">Brak przejść (stan końcowy)</p>
</section>
<section>
<h2>Observable - temperatura</h2>
<p>Wartość: {{ temperature.value.value }}°C | Obserwatorzy: {{ temperature.observerCount.value }}</p>
<div class="temp-controls">
<button @click="temperature.setValue(temperature.value.value - 5)">-5°C</button>
<button @click="temperature.setValue(temperature.value.value + 5)">+5°C</button>
<button @click="temperature.setValue(Math.round(Math.random() * 50))">Losowo</button>
</div>
<div class="history">
<div v-for="(h, i) in temperature.history.value.slice(-8)" :key="i" class="hist-item">
{{ h.time }}: {{ h.from }}°C -> {{ h.to }}°C
</div>
</div>
<div v-if="alerts.length" class="alerts">
<div v-for="(a, i) in alerts" :key="i" class="alert">{{ a }}</div>
</div>
</section>
</div>
</template>
<style scoped>
.lab { background: #0a0e27; color: #e0e0ff; padding: 1.5rem; min-height: 100vh; font-family: 'Courier New', monospace; transition: all 0.3s; }
.lab.light { background: #f0f0f5; color: #1a1a3f; }
h1 { color: #00ff88; text-align: center; }
h2 { color: #00b4d8; border-bottom: 1px solid #00b4d8; padding-bottom: 0.5rem; }
section { margin: 1.5rem 0; }
button { background: #00b4d8; color: #fff; border: none; padding: 0.5rem 1rem; border-radius: 4px; cursor: pointer; margin: 0.2rem; font-family: inherit; }
button:hover { background: #00ff88; color: #0a0e27; }
.state-display { font-size: 2rem; font-weight: bold; color: #00ff88; text-align: center; padding: 1rem; background: rgba(0,255,136,0.1); border: 2px solid #00ff88; border-radius: 8px; margin: 1rem 0; }
.transitions { display: flex; flex-wrap: wrap; gap: 0.5rem; justify-content: center; }
.trans-btn { background: #333; }
.trans-btn:hover { background: #00b4d8; }
.temp-controls { display: flex; gap: 0.5rem; margin: 0.5rem 0; }
.history { background: rgba(0,0,0,0.3); padding: 0.5rem; border-radius: 4px; margin: 0.5rem 0; }
.hist-item { font-size: 0.8rem; color: #aaa; padding: 0.2rem 0; }
.notifs { margin-top: 0.5rem; }
.notif { font-size: 0.8rem; color: #00b4d8; padding: 0.2rem 0; }
.alerts { margin-top: 0.5rem; }
.alert { background: rgba(255,0,85,0.15); border-left: 3px solid #ff0055; padding: 0.3rem 0.6rem; margin: 0.2rem 0; font-size: 0.85rem; color: #ff4444; }
.info { color: #666; font-style: italic; }
</style>Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Co oznacza wzorzec Reactive Singleton w composables?
2. Jaka jest główna zaleta wzorca State Machine z ref i computed?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Zbuduj useStateMachine z currentState (ref), availableTransitions (computed), transition() i canTransition(). Konfiguracja jako parametr.
- Układanie w pionie
Ułóż kroki tworzenia Reactive Singleton composable:
- Klikanie w kolejności
Ułóż kroki subskrypcji i emitowania zdarzenia:
- Edytor kodu
Zbuduj useObservable z value (ref), history (ref), subscribe() zwracający unsubscribe, setValue() i observers count.
- Układanie w poziomie
Ułóż wywołanie przejścia stanu w State Machine:
Zadania po tej lekcji
- PytanieReactive Singleton
- PytanieState Machine w Vue
- Zadanie z kodemPraktyka: State Machine composable
- Ułóż w kolejnościCykl życia Reactive Singleton
- Pytaniereadonly w Singleton
- Kliknij w kolejnościUżycie Event Bus composable
- Zadanie z kodemPraktyka: Reactive Observer pattern
- Ułóż w kolejnościTransition w State Machine