Kurs Vue.js · Moduł 9: Composables i VueUse

Performance i optymalizacja Composables

8 min czytania ·
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:

TechnikaKiedy używać
shallowRefDuże tablice/obiekty, rzadkie aktualizacje
computed zamiast funkcjiWartość zależy od reactive state
watch zamiast watchEffectKonkretne źródło do obserwacji
Cleanup w onUnmountedTimery, event listeners, WebSocket, fetch
Batch updatesVue sam łączy zmiany z jednego ticka; przy shallowRef podmieniaj całość raz
triggerRefMutacja 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. 1. Kiedy używamy shallowRef() zamiast ref()?

  2. 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:

  1. PytanieshallowRef vs ref
  2. PytanieComputed caching
  3. Zadanie z kodemPraktyka: shallowRef z batch update
  4. Ułóż w kolejnościJak powstaje wyciek pamięci w composable
  5. PytanietriggerRef w shallowRef
  6. Kliknij w kolejnościBatch update z shallowRef
  7. Zadanie z kodemPraktyka: Composable z computed caching
  8. PytanieWydajność watch vs watchEffect
  9. Ułóż w kolejnościTworzenie nowej tablicy w shallowRef
  10. PytanieZapobieganie wyciekom pamięci

Przydatne artykuły