Kurs Vue.js · Moduł 9: Composables i VueUse
Performance i optymalizacja Composables
W tej lekcji5
W stacji NOVA LAB każdy wat energii się liczy - tak samo w aplikacjach Vue każdy niepotrzebny render i obliczenie to strata wydajności. Problem zwykle nie jest widoczny od razu: panel z dziesięcioma czujnikami działa płynnie, ale przy dziesięciu tysiącach odczytów zaczyna się przycinać, a zapomniany timer po godzinie pracy zjada pamięć. Poznajmy techniki optymalizacji composables i dowiedzmy się, które z nich naprawdę pomagają.
shallowRef - płytka reaktywność
ref() tworzy głęboką reaktywność - Vue opakowuje każdy zagnieżdżony obiekt i śledzi zmianę każdego pola. shallowRef() reaguje tylko na zmianę całej wartości, nie wewnętrznych właściwości, więc przy dużych danych oszczędza pracę. Tę różnicę widać najlepiej na tablicy:
import { shallowRef, triggerRef } from 'vue'
// Duża lista danych - shallowRef jest wydajniejszy
const sensorReadings = shallowRef([])
// To NIE wywoła aktualizacji (płytka reaktywność)
sensorReadings.value.push({ id: 1, temp: 22 })
// To wywoła aktualizacje - przypisanie nowej tablicy
sensorReadings.value = [...sensorReadings.value, { id: 1, temp: 22 }]
// Alternatywnie: ręczne wyzwolenie aktualizacji
sensorReadings.value.push({ id: 2, temp: 23 })
triggerRef(sensorReadings) // Wymuś aktualizacjęPo push tablica naprawdę ma nowy element, ale Vue o tym nie wie i ekran się nie odświeży. Nowa tablica przypisana do .value albo wywołanie triggerRef informują Vue o zmianie. Composable dla dużych zbiorów trzyma się więc zasady: każda operacja tworzy nową tablicę:
<script setup>
import { shallowRef, triggerRef, computed } from 'vue'
// Wydajny composable dla dużych zbiorów danych
function useLargeDataset() {
const items = shallowRef([])
const count = computed(() => items.value.length)
function addItem(item) {
// Tworzymy nową tablicę - wyzwala reaktywność
items.value = [...items.value, item]
}
function addMany(newItems) {
// Jedno przypisanie i jedna kopia tablicy zamiast N
items.value = [...items.value, ...newItems]
}
function removeItem(id) {
items.value = items.value.filter(item => item.id !== id)
}
function updateItem(id, updates) {
items.value = items.value.map(item =>
item.id === id ? { ...item, ...updates } : item
)
}
return { items, count, addItem, addMany, removeItem, updateItem }
}
</script>filter i map z natury zwracają nowe tablice, więc pasują do shallowRef idealnie. addMany dodaje całą paczkę jednym przypisaniem - gdyby wywoływać addItem w pętli, każdy obrót kopiowałby całą, rosnącą tablicę.
Kiedy używać shallowRef:
- Duże tablice (setki lub tysiące elementów)
- Obiekty z wieloma zagnieżdżeniami
- Dane, które zmieniasz rzadko lub całościowo
Computed caching
Computed properties są automatycznie cachowane - przeliczają się tylko wtedy, gdy zmienia się ich zależność. To kluczowa optymalizacja. W poniższym composable porównujemy computed ze zwykłą funkcją wywoływaną w szablonie:
import { ref, computed } from 'vue'
function useFilteredExperiments() {
const experiments = ref([])
const searchQuery = ref('')
const category = ref('all')
// DOBRZE: computed jest cachowane
// Przelicza się TYLKO gdy experiments, searchQuery lub category się zmienia
const filtered = computed(() => {
console.log('Przeliczam filtrowane eksperymenty') // loguje rzadko
let result = experiments.value
if (searchQuery.value) {
const q = searchQuery.value.toLowerCase()
result = result.filter(e =>
e.name.toLowerCase().includes(q)
)
}
if (category.value !== 'all') {
result = result.filter(e => e.category === category.value)
}
return result
})
// ŹLE: funkcja przelicza za każdym renderem
function getFiltered() {
console.log('Przeliczam za każdym razem!') // loguje często
return experiments.value.filter(e =>
e.name.toLowerCase().includes(searchQuery.value.toLowerCase())
)
}
// DOBRZE: łączenie computed w łańcuch
const stats = computed(() => ({
total: filtered.value.length,
active: filtered.value.filter(e => e.status === 'active').length,
completed: filtered.value.filter(e => e.status === 'completed').length
}))
return { experiments, searchQuery, category, filtered, stats }
}Jeśli szablon odczyta filtered pięć razy w jednym renderze, filtr wykona się raz, a przy kolejnym renderze bez zmian w danych - wcale. getFiltered() w szablonie liczy od nowa przy każdym wywołaniu. stats korzysta z gotowego filtered, więc łańcuch nie powtarza filtrowania.
watchEffect vs watch - wydajność
watch i watchEffect różnią się nie tylko API, ale też tym, co śledzą. watchEffect rejestruje jako zależności te reaktywne wartości, które faktycznie odczytał podczas ostatniego uruchomienia, a watch śledzi tylko źródło podane w pierwszym argumencie:
import { ref, watch, watchEffect } from 'vue'
const temperature = ref(22)
const pressure = ref(101)
const humidity = ref(45)
// watchEffect - śledzi to, co odczytał przy ostatnim uruchomieniu
// temperature: zawsze; pressure: tylko gdy temperatura > 30;
// humidity: nigdy, bo efekt jej nie czyta
watchEffect(() => {
console.log('watchEffect:', temperature.value)
// pressure trafia do zależności dopiero wtedy,
// gdy warunek jest spełniony i ta linia się wykona
if (temperature.value > 30) {
console.log('Ciśnienie:', pressure.value)
}
})
// watch - śledzi TYLKO określone źródło
// Odpala się TYLKO przy zmianie temperature
watch(temperature, (newTemp) => {
console.log('watch:', newTemp)
// Możesz czytać inne refs bez tworzenia zależności
if (newTemp > 30) {
console.log('Ciśnienie:', pressure.value)
}
})W praktyce wygląda to tak: przy 22°C zmiana ciśnienia nie uruchamia watchEffect, zmiana wilgotności nie uruchamia go nigdy, a po wzroście temperatury do 35°C efekt zaczyna reagować także na ciśnienie. watch przez cały czas odpala się wyłącznie przy zmianie temperatury.
Reguła: używaj watch, gdy potrzebujesz reagować na konkretne zmiany. Używaj watchEffect, gdy chcesz automatycznego śledzenia wielu zależności.
Wycieki pamięci w Composables
Jeden z najczęstszych problemów - niesprzątnięte zasoby powodują wycieki pamięci. Wyciek powstaje w czterech krokach: composable uruchamia setInterval w onMounted, komponent zostaje odmontowany, timer dalej tyka i trzyma referencję do stanu, a pamięci nie da się zwolnić. Porównaj obie wersje:
import { ref, onMounted, onUnmounted, watch } from 'vue'
// ŹLE - wyciek pamięci!
function useLeakyTimer() {
const seconds = ref(0)
onMounted(() => {
setInterval(() => { // Nigdy nie czyścimy!
seconds.value++
}, 1000)
})
return { seconds }
}
// DOBRZE - poprawny cleanup
function useSafeTimer() {
const seconds = ref(0)
const isRunning = ref(false)
let intervalId = null
function start() {
if (isRunning.value) return
isRunning.value = true
intervalId = setInterval(() => {
seconds.value++
}, 1000)
}
function stop() {
if (!isRunning.value) return
isRunning.value = false
clearInterval(intervalId)
intervalId = null
}
// Zawsze czyścimy w onUnmounted
onUnmounted(() => {
if (intervalId) {
clearInterval(intervalId)
}
})
return { seconds, isRunning, start, stop }
}Każde zamontowanie wersji "ŹLE" dokłada kolejny nieśmiertelny timer. Ta sama zasada dotyczy żądań sieciowych: odpowiedź, która przyjdzie po odmontowaniu komponentu, nie ma już dokąd trafić. Przeglądarkowe AbortController pozwala anulować fetch - przekazujesz jego signal do żądania, a abort() przerywa je w onUnmounted:
import { ref, onMounted, onUnmounted } from 'vue'
function useSensorFeed(url) {
const data = ref(null)
const loading = ref(false)
const error = ref(null)
let controller = null
async function fetchData() {
controller = new AbortController()
loading.value = true
error.value = null
try {
const response = await fetch(url, { signal: controller.signal })
data.value = await response.json()
} catch (e) {
if (e.name !== 'AbortError') error.value = e.message
} finally {
loading.value = false
}
}
onMounted(() => fetchData())
onUnmounted(() => controller?.abort())
return { data, loading, error, fetchData }
}Przerwany fetch kończy się błędem o nazwie AbortError, który celowo pomijamy, bo to nie awaria, tylko nasza decyzja. Kolejność kroków jest stała: refy, funkcja pobierająca, wywołanie w onMounted, anulowanie w onUnmounted i zwrócenie API.
Checklist wydajności composables
Poniższa tabela zbiera techniki z tej lekcji:
| Technika | Kiedy używać |
|---|---|
shallowRef | Duże tablice/obiekty, rzadkie aktualizacje |
computed zamiast funkcji | Wartość zależy od reactive state |
watch zamiast watchEffect | Konkretne źródło do obserwacji |
Cleanup w onUnmounted | Timery, event listeners, WebSocket, fetch |
| Batch updates | Vue sam łączy zmiany z jednego ticka; przy shallowRef podmieniaj całość raz |
triggerRef | Mutacja shallowRef bez tworzenia kopii |
Wiersz o batch updates wymaga wyjaśnienia, bo krąży wokół niego popularny mit. Vue buforuje aktualizacje DOM do następnego ticka, więc komponent renderuje się raz, niezależnie od tego, ile pól zmienisz w jednej funkcji:
// Batch updates - Vue i tak łączy zmiany z jednego ticka
import { ref } from 'vue'
function useBatchUpdate() {
const data = ref({ temp: 0, pressure: 0, humidity: 0 })
// Trzy mutacje w jednym ticku - wciąż 1 render
function updateFields(temp, pressure, humidity) {
data.value.temp = temp
data.value.pressure = pressure
data.value.humidity = humidity
}
// Podmiana całego obiektu - też 1 render
// (jedyna droga, gdyby data było shallowRef)
function replaceData(temp, pressure, humidity) {
data.value = { temp, pressure, humidity }
}
return { data, updateFields, replaceData }
}Obie funkcje dają jeden render, co łatwo sprawdzić licznikiem renderów. Różnica pojawia się dopiero przy watcherze z opcją flush: 'sync', który przy updateFields odpali się trzy razy, oraz przy shallowRef, gdzie zmiana pojedynczego pola w ogóle nie zostałaby zauważona.
Moja rada: nie optymalizuj na zapas. Zacznij od zwykłego ref i computed, a shallowRef włącz, gdy pomiar pokaże problem z dużymi danymi. Sprzątania w onUnmounted nie odkładaj nigdy - to nie optymalizacja, tylko obowiązek. W edytorze poniżej porównasz ref i shallowRef na licznikach aktualizacji, zobaczysz cache computed i uruchomisz timer z wyciekiem oraz bez niego.
Zapamiętaj: wydajna stacja nie przelicza tego, co już wie, i zawsze gasi światło w module, który opuszcza.
Kod do tej lekcji: App.vue
<script setup>
import { ref, shallowRef, computed, watch, triggerRef, onUnmounted } from 'vue'
// ===== DEMO WYDAJNOŚCI =====
// 1. Porównanie shallowRef i ref
const regularItems = ref([])
const shallowItems = shallowRef([])
const renderCounts = ref({ regular: 0, shallow: 0 })
// Zliczanie reakcji (renderów)
watch(regularItems, () => { renderCounts.value.regular++ }, { deep: true })
watch(shallowItems, () => { renderCounts.value.shallow++ })
function addToRegular() {
regularItems.value.push({ id: Date.now(), temp: Math.random() * 50 })
// Każdy push uruchamia głęboki watch
}
function addToShallow() {
// shallowRef zareaguje tylko na nową tablicę
shallowItems.value = [...shallowItems.value, { id: Date.now(), temp: Math.random() * 50 }]
}
function addBatchToShallow(count) {
const newItems = Array.from({ length: count }, (_, i) => ({
id: Date.now() + i, temp: Math.random() * 50
}))
// Jedna aktualizacja dla wszystkich elementów
shallowItems.value = [...shallowItems.value, ...newItems]
}
// 2. Demo cache w computed
const experiments = ref([
{ name: 'Analiza gleby', category: 'geologia', status: 'active' },
{ name: 'Test atmosfery', category: 'atmosfera', status: 'completed' },
{ name: 'Poszukiwanie wody', category: 'geologia', status: 'active' },
{ name: 'Skan promieniowania', category: 'bezpieczeństwo', status: 'active' },
{ name: 'Wzrost roślin', category: 'biologia', status: 'completed' }
])
const searchQuery = ref('')
const computedCallCount = ref(0)
// Computed: z cache, przelicza się tylko po zmianie zależności
const filteredExperiments = computed(() => {
computedCallCount.value++ // Liczymy wywołania
if (!searchQuery.value) return experiments.value
return experiments.value.filter(e =>
e.name.toLowerCase().includes(searchQuery.value.toLowerCase())
)
})
// Kilka odczytów filteredExperiments - computed korzysta z cache
const filteredCount = computed(() => filteredExperiments.value.length)
const activeFiltered = computed(() =>
filteredExperiments.value.filter(e => e.status === 'active')
)
// 3. Demo wycieku pamięci
const timerSeconds = ref(0)
let leakyInterval = null
const leakyIntervals = ref(0)
function createLeakyTimer() {
// ŹLE: referencja do sprzątania nie jest poprawnie zapisana
leakyInterval = setInterval(() => { timerSeconds.value++ }, 1000)
leakyIntervals.value++
}
function createSafeTimer() {
if (leakyInterval) clearInterval(leakyInterval)
leakyInterval = setInterval(() => { timerSeconds.value++ }, 1000)
}
function stopTimer() {
if (leakyInterval) {
clearInterval(leakyInterval)
leakyInterval = null
}
timerSeconds.value = 0
}
onUnmounted(() => {
if (leakyInterval) clearInterval(leakyInterval)
})
</script>
<template>
<div class="perf-lab">
<h1>Optymalizacja wydajności - NOVA LAB</h1>
<section>
<h2>shallowRef vs ref</h2>
<div class="compare">
<div class="col">
<h3>ref (głęboki)</h3>
<p>Elementy: {{ regularItems.length }} | Rendery: {{ renderCounts.regular }}</p>
<button @click="addToRegular">Dodaj element</button>
<button @click="regularItems = []">Wyczyść</button>
</div>
<div class="col">
<h3>shallowRef (płytki)</h3>
<p>Elementy: {{ shallowItems.length }} | Rendery: {{ renderCounts.shallow }}</p>
<button @click="addToShallow">Dodaj element</button>
<button @click="addBatchToShallow(10)">Dodaj 10 naraz</button>
<button @click="shallowItems = []">Wyczyść</button>
</div>
</div>
</section>
<section>
<h2>Cache w computed</h2>
<input v-model="searchQuery" placeholder="Szukaj eksperymentów..." class="search" />
<p class="stats">
Wywołania computed: {{ computedCallCount }} |
Po filtrze: {{ filteredCount }} |
Aktywne: {{ activeFiltered.length }}
</p>
<div v-for="e in filteredExperiments" :key="e.name" class="exp-item" :class="e.status">
{{ e.name }} <span class="cat">[{{ e.category }}]</span>
<span class="status-tag">{{ e.status }}</span>
</div>
</section>
<section>
<h2>Zapobieganie wyciekom pamięci</h2>
<p>Timer: {{ timerSeconds }} s | Aktywne interwały: {{ leakyIntervals }}</p>
<div class="btns">
<button @click="createLeakyTimer" class="bad">Timer z wyciekiem (ŹLE)</button>
<button @click="createSafeTimer" class="good">Bezpieczny timer (DOBRZE)</button>
<button @click="stopTimer">Zatrzymaj wszystko</button>
</div>
<p class="hint">Kliknij kilka razy "Timer z wyciekiem" - każde kliknięcie tworzy NOWY interwał i nie czyści starego!</p>
</section>
</div>
</template>
<style scoped>
.perf-lab { background: #0a0e27; color: #e0e0ff; padding: 1.5rem; min-height: 100vh; font-family: 'Courier New', monospace; }
h1 { color: #00ff88; text-align: center; }
h2 { color: #00b4d8; border-bottom: 1px solid #00b4d8; padding-bottom: 0.5rem; margin-top: 2rem; }
h3 { color: #00ff88; margin: 0 0 0.5rem; }
section { margin: 1.5rem 0; }
.compare { display: grid; grid-template-columns: 1fr 1fr; gap: 1rem; }
.col { background: rgba(0,180,216,0.1); border: 1px solid #00b4d8; border-radius: 8px; padding: 1rem; }
button { background: #00b4d8; color: #fff; border: none; padding: 0.4rem 0.8rem; border-radius: 4px; cursor: pointer; margin: 0.2rem; font-family: inherit; }
button:hover { background: #00ff88; color: #0a0e27; }
button.bad { background: #ff0055; }
button.bad:hover { background: #ff4444; color: #fff; }
button.good { background: #00ff88; color: #0a0e27; }
.search { width: 100%; background: #1a1e3f; border: 1px solid #00b4d8; color: #fff; padding: 0.6rem; border-radius: 4px; margin: 0.5rem 0; font-family: inherit; }
.stats { color: #00b4d8; font-size: 0.9rem; }
.exp-item { padding: 0.5rem; margin: 0.3rem 0; background: rgba(0,0,0,0.3); border-radius: 4px; display: flex; align-items: center; gap: 0.5rem; }
.exp-item.active { border-left: 3px solid #00ff88; }
.exp-item.completed { border-left: 3px solid #888; opacity: 0.7; }
.cat { color: #888; font-size: 0.8rem; }
.status-tag { margin-left: auto; font-size: 0.75rem; padding: 0.15rem 0.5rem; border-radius: 10px; background: rgba(0,255,136,0.2); color: #00ff88; }
.exp-item.completed .status-tag { background: rgba(136,136,136,0.2); color: #888; }
.btns { display: flex; gap: 0.5rem; margin: 0.5rem 0; }
.hint { color: #ffb400; font-size: 0.8rem; font-style: italic; margin-top: 0.5rem; }
</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. Kiedy używamy shallowRef() zamiast ref()?
2. Jaka jest główna zaleta computed() nad zwykłą funkcją?
To 2 z 5 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Stwórz shallowRef dla listy sensorów. Dodaj addMany() który tworzy nową tablicę zamiast push. Porównaj z ref.
- Układanie w pionie
Ułóż kroki powstawania wycieku pamięci w useLeakyTimer:
- Klikanie w kolejności
Ułóż poprawny batch update dla shallowRef:
- Edytor kodu
Użyj computed() dla filtered i stats zamiast funkcji. Pokaż że computed nie przelicza się bez zmiany zależności.
- Układanie w poziomie
Ułóż poprawne usuwanie elementu z shallowRef:
Zadania po tej lekcji
- PytanieshallowRef vs ref
- PytanieComputed caching
- Zadanie z kodemPraktyka: shallowRef z batch update
- Ułóż w kolejnościJak powstaje wyciek pamięci w composable
- PytanietriggerRef w shallowRef
- Kliknij w kolejnościBatch update z shallowRef
- Zadanie z kodemPraktyka: Composable z computed caching
- PytanieWydajność watch vs watchEffect
- Ułóż w kolejnościTworzenie nowej tablicy w shallowRef
- PytanieZapobieganie wyciekom pamięci