Kurs Vue.js · Moduł 9: Composables i VueUse
Zaawansowane wzorce Composables
W tej lekcji5
Witaj w Laboratorium Naukowym NOVA LAB! Znasz już podstawy composables z Drukarni 3D - teraz czas na zaawansowane wzorce projektowe. Zacznijmy od problemu: stacja pilnuje trzech zasobów, czyli tlenu, paliwa i wody. Każdy potrzebuje tej samej logiki - aktualnego poziomu, procentu, alarmu przy niskim stanie, zużycia i uzupełniania. Skopiowanie jej do trzech komponentów oznacza trzy miejsca do poprawiania przy każdym błędzie. Jak inżynierowie NOVA LAB projektują modułowe systemy stacji kosmicznej, tak my zaprojektujemy composables gotowe na każde wyzwanie.
Czego się nauczysz
W Laboratorium Naukowym opanujesz protokoły badawcze na poziomie eksperta:
- tworzyć fabryki composables i łączyć composables w większe systemy,
- dostarczać wspólny kontekst przez
provideiinjectoraz obsługiwać błędy z ponawianiem, - budować reaktywne wzorce projektowe: singleton, event bus, automat stanów i obserwatora,
- korzystać z gotowych composables biblioteki VueUse,
- testować composables w Vitest i optymalizować ich wydajność,
- przygotować composables do produkcji: typy, organizację plików i opcje konfiguracyjne.
Factory Composables
Factory composable to funkcja, która tworzy composables z różną konfiguracją - jak fabryka modułów stacji, gdzie każdy moduł ma te same interfejsy, ale różne parametry. Nazwa zaczyna się od create, a nie od use, bo podkreśla, że każde wywołanie wytwarza nowy, niezależny egzemplarz. Oto fabryka przyjmująca nazwę zasobu i maksymalną pojemność:
import { ref, computed } from 'vue'
// Factory: tworzy composable dla dowolnego zasobu
function createResourceManager(resourceName, maxCapacity = 100) {
const currentLevel = ref(maxCapacity)
const isLow = computed(() => currentLevel.value < maxCapacity * 0.2)
const isCritical = computed(() => currentLevel.value < maxCapacity * 0.05)
const percentage = computed(() =>
Math.round((currentLevel.value / maxCapacity) * 100)
)
function consume(amount) {
currentLevel.value = Math.max(0, currentLevel.value - amount)
}
function refill(amount) {
currentLevel.value = Math.min(maxCapacity, currentLevel.value + amount)
}
return {
resourceName,
currentLevel,
maxCapacity,
percentage,
isLow,
isCritical,
consume,
refill
}
}Poziom startuje od pełnej pojemności, isLow włącza się poniżej 20%, a isCritical poniżej 5%. Math.max i Math.min pilnują, by poziom nie spadł poniżej zera ani nie przekroczył pojemności. Teraz wyprodukujmy trzy menedżery:
// Użycie - każdy zasób ma te same metody, ale niezależny stan
const oxygen = createResourceManager('Oxygen', 500)
const fuel = createResourceManager('Fuel', 1000)
const water = createResourceManager('Water', 200)
oxygen.consume(50) // nie wpływa na fuel ani waterPo tym wywołaniu tlen ma 450 jednostek, czyli 90%, a paliwo nadal pełne 1000. Każde wywołanie fabryki utworzyło własne refy, więc zasoby niczego ze sobą nie dzielą.
Kompozycja Composables
Composables mogą używać innych composables - to jak łączenie modułów stacji w większe systemy. Najpierw bazowy composable powiadomień, który dodaje nowe wpisy na początek listy i trzyma najwyżej 50 ostatnich:
import { ref, computed, watch } from 'vue'
// Bazowy composable
function useNotifications() {
const notifications = ref([])
function addNotification(message, type = 'info') {
notifications.value.unshift({
id: Date.now(),
message,
type,
timestamp: new Date()
})
// Ogranicz do 50 notyfikacji
if (notifications.value.length > 50) {
notifications.value.pop()
}
}
function clearAll() {
notifications.value = []
}
return { notifications, addNotification, clearAll }
}unshift wstawia element na początek tablicy, a pop usuwa ostatni, najstarszy. Monitor laboratorium wywołuje ten composable w środku i obserwuje czujniki przez watch, porównując odczyty z progami z parametru thresholds:
// Composable korzystający z innego composable
function useLabMonitor(thresholds) {
const temperature = ref(22)
const pressure = ref(101)
const { notifications, addNotification, clearAll } = useNotifications()
watch(temperature, (val) => {
if (val > thresholds.maxTemp) {
addNotification(
`Temperatura krytyczna: ${val}°C!`,
'danger'
)
}
})
watch(pressure, (val) => {
if (val < thresholds.minPressure) {
addNotification(
`Ciśnienie poniżej normy: ${val} kPa`,
'warning'
)
}
})
return {
temperature,
pressure,
notifications,
addNotification,
clearAll
}
}Komponent widzi jeden composable, choć pod spodem pracują dwa. Każde wywołanie useLabMonitor dostaje przy tym własną listę powiadomień - drugi monitor zaczyna z pustą listą.
Dependency Injection w Composables
Mechanizm provide i inject znasz ze Stacji Komunikacji. Opakowany w parę composables staje się centralnym systemem stacji, dostępnym dla każdego modułu poniżej. Kluczem jest Symbol, który gwarantuje, że żadna inna biblioteka nie nadpisze naszego klucza:
import { ref, provide, inject } from 'vue'
// Symbol jako klucz - unikamy kolizji nazw
const MissionContextKey = Symbol('MissionContext')
// Composable dostarczający kontekst
function provideMissionContext() {
const missionName = ref('Mars Exploration 2087')
const crewCount = ref(6)
const missionDay = ref(1)
const context = {
missionName,
crewCount,
missionDay,
advanceDay() { missionDay.value++ }
}
provide(MissionContextKey, context)
return context
}
// Composable konsumujący kontekst
function useMissionContext() {
const context = inject(MissionContextKey)
if (!context) {
throw new Error(
'useMissionContext wymaga provideMissionContext w komponencie nadrzędnym'
)
}
return context
}Jeśli ktoś wywoła useMissionContext bez dostawcy wyżej w drzewie, od razu dostanie czytelny błąd zamiast tajemniczego undefined. Oba composables wywołujesz w <script setup>, bo provide i inject działają tylko podczas tworzenia komponentu:
<!-- ParentComponent.vue -->
<script setup>
const { missionName, missionDay, advanceDay } = provideMissionContext()
</script>
<!-- ChildComponent.vue (dowolna głębokość zagnieżdżenia) -->
<script setup>
const { missionName, missionDay } = useMissionContext()
// Automatycznie reaktywne - zmiana w rodzicu aktualizuje dzieci
</script>Kontekst zawiera refy, więc gdy rodzic wywoła advanceDay(), każde dziecko od razu zobaczy nowy dzień misji.
Obsługa Błędów w Composables
Każdy system stacji musi mieć zabezpieczenia na wypadek awarii. Poniższy composable opakowuje dowolną funkcję asynchroniczną: pilnuje stanu ładowania, zapisuje błąd w refie zamiast go zgubić i pozwala ponowić próbę najwyżej trzy razy:
import { ref, computed } from 'vue'
function useAsyncOperation(asyncFn) {
const data = ref(null)
const error = ref(null)
const loading = ref(false)
const retryCount = ref(0)
const MAX_RETRIES = 3
const hasError = computed(() => error.value !== null)
const canRetry = computed(() => retryCount.value < MAX_RETRIES)
async function execute(...args) {
loading.value = true
error.value = null
try {
data.value = await asyncFn(...args)
retryCount.value = 0 // Reset po sukcesie
} catch (e) {
error.value = e.message || 'Nieznany błąd'
console.error(`Operacja nieudana: ${error.value}`)
} finally {
loading.value = false
}
}
async function retry(...args) {
if (!canRetry.value) {
error.value = 'Przekroczono limit prób'
return
}
retryCount.value++
await execute(...args)
}
return { data, error, loading, hasError, canRetry, retryCount, execute, retry }
}Blok try/catch/finally gwarantuje, że loading wróci do false niezależnie od wyniku. Po trzech nieudanych ponowieniach retry przestaje wołać serwer i ustawia komunikat o przekroczeniu limitu. Tak wygląda użycie z czujnikiem temperatury:
// Użycie
const sensorData = useAsyncOperation(async (sensorId) => {
const response = await fetch(`/api/sensors/${sensorId}`)
if (!response.ok) throw new Error('Błąd pobierania danych')
return response.json()
})
// W komponencie
await sensorData.execute('temp-sensor-1')
if (sensorData.hasError.value && sensorData.canRetry.value) {
await sensorData.retry('temp-sensor-1')
}Uwaga na ostatnie linie: await na najwyższym poziomie <script setup> zamienia komponent w zależność asynchroniczną, która wymaga <Suspense> - pamiętasz to z Magazynu Modułów. W praktyce execute wywołuj w onMounted albo w obsłudze kliknięcia.
Moja rada: zwracaj z composable zwykły obiekt z refami, jak we wszystkich przykładach tej lekcji. Komponent może go wtedy zdestrukturyzować bez utraty reaktywności. W następnej lekcji z tych klocków zbudujemy klasyczne wzorce projektowe. W edytorze poniżej menedżery zasobów, monitor z powiadomieniami i operacja z ponawianiem działają na jednym panelu.
Zapamiętaj: composable to moduł stacji ze standardowym złączem - fabryka wytwarza ich tyle, ile trzeba, a każdy ma własny, niezależny stan.
Kod do tej lekcji: App.vue
<script setup>
import { ref, computed, provide, inject, readonly } from 'vue'
// ===== COMPOSABLE-FABRYKA =====
// Tworzy composable dla dowolnego zasobu stacji
function createResourceManager(resourceName, maxCapacity = 100) {
const currentLevel = ref(maxCapacity)
const isLow = computed(() => currentLevel.value < maxCapacity * 0.2)
const isCritical = computed(() => currentLevel.value < maxCapacity * 0.05)
const percentage = computed(() =>
Math.round((currentLevel.value / maxCapacity) * 100)
)
function consume(amount) {
currentLevel.value = Math.max(0, currentLevel.value - amount)
}
function refill(amount) {
currentLevel.value = Math.min(maxCapacity, currentLevel.value + amount)
}
return {
resourceName,
currentLevel,
maxCapacity,
percentage,
isLow,
isCritical,
consume,
refill
}
}
// ===== KOMPOZYCJA COMPOSABLES =====
// useNotifications jest używany wewnątrz useLabMonitor
function useNotifications() {
const notifications = ref([])
function addNotification(message, type = 'info') {
notifications.value.unshift({
id: Date.now(),
message,
type,
timestamp: new Date().toLocaleTimeString()
})
if (notifications.value.length > 20) notifications.value.pop()
}
function clearAll() { notifications.value = [] }
return { notifications, addNotification, clearAll }
}
// ===== OBSŁUGA BŁĘDÓW =====
function useAsyncOperation(asyncFn) {
const data = ref(null)
const error = ref(null)
const loading = ref(false)
const retryCount = ref(0)
async function execute(...args) {
loading.value = true
error.value = null
try {
data.value = await asyncFn(...args)
} catch (e) {
error.value = e.message || 'Nieznany błąd'
} finally {
loading.value = false
}
}
async function retry(...args) {
if (retryCount.value >= 3) {
error.value = 'Osiągnięto limit ponowień'
return
}
retryCount.value++
await execute(...args)
}
return { data, error, loading, retryCount, execute, retry }
}
// === Tworzenie zasobów (wzorzec fabryki) ===
const oxygen = createResourceManager('Tlen', 500)
const fuel = createResourceManager('Paliwo', 1000)
const water = createResourceManager('Woda', 200)
// === Powiadomienia (kompozycja) ===
const { notifications, addNotification, clearAll } = useNotifications()
// === Operacja asynchroniczna (obsługa błędów) ===
const sensorOp = useAsyncOperation(async (id) => {
// Symulacja API
await new Promise(r => setTimeout(r, 800))
if (Math.random() < 0.3) throw new Error('Utracono połączenie')
return { id, temp: Math.round(Math.random() * 50 - 20), status: 'OK' }
})
function consumeResource(resource, amount) {
resource.consume(amount)
if (resource.isCritical.value) {
addNotification(resource.resourceName + ': poziom krytyczny!', 'danger')
} else if (resource.isLow.value) {
addNotification(resource.resourceName + ': niski poziom', 'warning')
}
}
</script>
<template>
<div class="lab">
<h1>Zaawansowane composables - NOVA LAB</h1>
<section class="resources">
<h2>Composables-fabryki - zasoby</h2>
<div class="res-grid">
<div v-for="res in [oxygen, fuel, water]" :key="res.resourceName" class="res-card"
:class="{ low: res.isLow.value, critical: res.isCritical.value }">
<h3>{{ res.resourceName }}</h3>
<div class="bar"><div class="fill" :style="{ width: res.percentage.value + '%' }"></div></div>
<p>{{ res.currentLevel.value }} / {{ res.maxCapacity }} ({{ res.percentage.value }}%)</p>
<div class="btns">
<button @click="consumeResource(res, 20)">Zużyj 20</button>
<button @click="consumeResource(res, 50)">Zużyj 50</button>
<button @click="res.refill(30)">Uzupełnij 30</button>
</div>
</div>
</div>
</section>
<section class="async-section">
<h2>Obsługa błędów - operacja asynchroniczna</h2>
<button @click="sensorOp.execute('T-01')" :disabled="sensorOp.loading.value">
{{ sensorOp.loading.value ? 'Ładowanie...' : 'Odczytaj czujnik' }}
</button>
<button v-if="sensorOp.error.value" @click="sensorOp.retry('T-01')">
Ponów ({{ sensorOp.retryCount.value }}/3)
</button>
<div v-if="sensorOp.data.value" class="result ok">{{ JSON.stringify(sensorOp.data.value) }}</div>
<div v-if="sensorOp.error.value" class="result err">Błąd: {{ sensorOp.error.value }}</div>
</section>
<section class="notif-section">
<h2>Powiadomienia (kompozycja)</h2>
<button @click="clearAll" v-if="notifications.length">Wyczyść wszystko</button>
<div v-for="n in notifications" :key="n.id" class="notif" :class="n.type">
<span class="time">{{ n.timestamp }}</span> {{ n.message }}
</div>
<p v-if="!notifications.length" class="empty">Brak powiadomień</p>
</section>
</div>
</template>
<style scoped>
.lab { background: #0a0e27; color: #e0e0ff; padding: 1.5rem; min-height: 100vh; font-family: 'Courier New', monospace; }
h1 { color: #00ff88; text-align: center; margin-bottom: 2rem; }
h2 { color: #00b4d8; border-bottom: 1px solid #00b4d8; padding-bottom: 0.5rem; }
.res-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem; margin: 1rem 0; }
.res-card { background: rgba(0,180,216,0.1); border: 2px solid #00b4d8; border-radius: 8px; padding: 1rem; }
.res-card.low { border-color: #ffb400; }
.res-card.critical { border-color: #ff0055; animation: pulse 1s infinite; }
.res-card h3 { color: #00ff88; margin: 0 0 0.5rem; }
.bar { background: #1a1e3f; border-radius: 4px; height: 16px; overflow: hidden; margin: 0.5rem 0; }
.fill { height: 100%; background: linear-gradient(90deg, #00ff88, #00b4d8); transition: width 0.3s; border-radius: 4px; }
.res-card.low .fill { background: linear-gradient(90deg, #ffb400, #ff8800); }
.res-card.critical .fill { background: #ff0055; }
.btns { display: flex; gap: 0.3rem; flex-wrap: wrap; margin-top: 0.5rem; }
button { background: #00b4d8; color: #fff; border: none; padding: 0.4rem 0.8rem; border-radius: 4px; cursor: pointer; font-family: inherit; }
button:hover { background: #00ff88; color: #0a0e27; }
button:disabled { opacity: 0.5; }
.async-section { margin: 1.5rem 0; }
.async-section button { margin-right: 0.5rem; }
.result { padding: 0.5rem; border-radius: 4px; margin-top: 0.5rem; font-size: 0.9rem; }
.result.ok { background: rgba(0,255,136,0.1); border: 1px solid #00ff88; }
.result.err { background: rgba(255,0,85,0.1); border: 1px solid #ff0055; color: #ff0055; }
.notif-section { margin: 1.5rem 0; }
.notif { padding: 0.4rem 0.8rem; margin: 0.3rem 0; border-radius: 4px; font-size: 0.85rem; }
.notif.info { background: rgba(0,180,216,0.15); border-left: 3px solid #00b4d8; }
.notif.warning { background: rgba(255,180,0,0.15); border-left: 3px solid #ffb400; }
.notif.danger { background: rgba(255,0,85,0.15); border-left: 3px solid #ff0055; }
.time { color: #888; margin-right: 0.5rem; }
.empty { color: #666; font-style: italic; }
@keyframes pulse { 0%,100% { opacity: 1; } 50% { opacity: 0.6; } }
</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 to jest factory composable?
2. Jaka jest główna zaleta kompozycji composables (composable używający innego composable)?
To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Zbuduj createResourceManager przyjmujący nazwę i maxCapacity. Zwróć currentLevel (ref), percentage (computed), consume() i refill().
- Klikanie w kolejności
Ułóż poprawną składnię provide z Symbol:
- Edytor kodu
Zbuduj useAsyncOperation z execute(), retry(), refs: data, error, loading, retryCount i computed: hasError, canRetry.
- Układanie w poziomie
Ułóż poprawne wywołanie inject z kluczem kontekstu:
Zadania po tej lekcji
- PytanieFactory Composables
- PytanieKompozycja composables
- Zadanie z kodemPraktyka: Factory composable
- PytanieDependency Injection w composables
- Kliknij w kolejnościSkładnia provide w composable
- PytanieObsługa błędów w composables
- Zadanie z kodemPraktyka: Composable z error handling
- Ułóż w kolejnościWywołanie inject w composable