Kurs Vue.js · Moduł 4: Computed i watch

Watch - System Monitorowania

5 min czytania ·
W tej lekcji4

Computed odpowiada na pytanie "ile wynosi", ale spora część pracy stacji to nie wartości, tylko reakcje. Gdy operator wpisuje nazwę modułu, trzeba odpytać bazę NOVA LAB. Gdy temperatura reaktora przekroczy normę, trzeba podnieść alarm i zapisać zdarzenie w dzienniku. Takich efektów ubocznych nie wolno wkładać do computed, bo jego getter ma tylko liczyć i od razu zwracać wynik. Do reagowania na zmiany służy watcher, czyli czujnik alarmowy Centrum Kontroli.

Podstawowy watch()

Funkcja watch przyjmuje dwa argumenty i opcjonalnie trzeci. Pierwszy to źródło, czyli to, co obserwujemy: ref, obiekt z reactive, getter albo tablica takich źródeł. Drugi to callback, który Vue wywoła po każdej zmianie źródła, przekazując mu nową i poprzednią wartość. Watcher jest domyślnie leniwy: przy utworzeniu nic nie robi i czeka na pierwszą zmianę. Poniżej wyszukiwarka modułów, w której callback jest funkcją asynchroniczną, a opóźnienie odpowiedzi bazy udaje await na obietnicy rozwiązywanej przez setTimeout.

<template>
  <div class="module-search" style="background: #0a0e27; color: #00ff88;">
    <input v-model="searchQuery" placeholder="Szukaj modułu..." style="background: #1a1e37; color: #00ff88;" />
    <p v-if="isSearching" style="color: #00b4d8;">Wyszukiwanie...</p>
    <ul>
      <li v-for="result in searchResults" :key="result.id" style="border-bottom: 1px solid #00b4d8;">
        {{ result.name }}
      </li>
    </ul>
  </div>
</template>

<script setup>
import { ref, watch } from 'vue'

const searchQuery = ref('')
const searchResults = ref([])
const isSearching = ref(false)

// Watch na pojedynczą wartość
watch(searchQuery, async (newQuery, oldQuery) => {
  console.log(`Search changed: "${oldQuery}" → "${newQuery}"`)

  if (newQuery.length < 2) {
    searchResults.value = []
    return
  }

  isSearching.value = true

  // Symulacja API call do bazy NOVA LAB
  await new Promise(resolve => setTimeout(resolve, 500))

  searchResults.value = [
    { id: 1, name: `Module: ${newQuery}` }
  ]

  isSearching.value = false
})
</script>

Wpisz "ox", a w konsoli pojawi się linia ze starym i nowym zapytaniem, a po pół sekundy wynik wyszukiwania. Zapytania krótsze niż dwa znaki czyszczą listę i kończą callback instrukcją return, zanim cokolwiek zostanie wysłane. Co się nie zmieniło: searchQuery nadal jest zwykłym ref podpiętym przez v-model, a watcher niczego w nim nie zapisuje, tylko nasłuchuje. Zwróć też uwagę na moment reakcji. Vue nie wywołuje callbacku w tej samej linijce, w której zmieniasz wartość: wychwytuje zmianę i obsługuje ją w następnym ticku, przed odświeżeniem DOM. Dwie zmiany w jednym ticku dają więc jedno wywołanie, już z najnowszą wartością.

Opcje Watch

Trzeci argument to obiekt opcji. immediate: true każe wykonać callback od razu przy tworzeniu watchera, ze starą wartością równą undefined, co przydaje się do pobrania danych na starcie panelu. deep: true włącza głębokie obserwowanie zagnieżdżonych obiektów. flush wybiera moment wywołania: 'pre' (domyślnie, przed aktualizacją DOM), 'post' (po aktualizacji, gdy chcesz czytać odświeżony DOM) albo 'sync' (natychmiast przy każdej zmianie). once: true, dostępne od Vue 3.4, zatrzymuje watcher po pierwszym wywołaniu.

import { ref, watch } from 'vue'

const count = ref(0)

watch(count, (newValue) => {
  console.log('Count:', newValue)
}, {
  immediate: true,  // Wywołaj natychmiast przy inicjalizacji
  deep: true,       // Głębokie obserwowanie obiektów
  flush: 'post',    // Kiedy wykonać: 'pre', 'post', 'sync'
  once: true        // Tylko raz (Vue 3.4+)
})

Ten blok to ściąga, a nie wzór do skopiowania. count jest liczbą, więc deep niczego tu nie zmienia, a połączenie immediate z once oznacza, że callback wykona się raz, od razu przy tworzeniu, i watcher natychmiast się wyłączy. W praktyce konfiguracja idzie zawsze w tej samej kolejności: import watch z vue, źródło, callback, a na końcu tylko te opcje, których naprawdę potrzebujesz.

Watch na Wiele Źródeł

Systemy podtrzymywania życia ocenia się razem: tlen i temperaturę. Zamiast dwóch watcherów podajesz tablicę źródeł. Callback dostaje wtedy tablicę nowych wartości i tablicę starych, w tej samej kolejności co źródła, a destrukturyzacja [newO2, newTemp] od razu nadaje im nazwy.

import { ref, watch } from 'vue'

const oxygenLevel = ref(95)
const temperature = ref(22)

// Tablica źródeł - monitorowanie wielu parametrów
watch([oxygenLevel, temperature], ([newO2, newTemp], [oldO2, oldTemp]) => {
  console.log(`Life support changed:
    O2: ${oldO2}% → ${newO2}%
    Temp: ${oldTemp}°C → ${newTemp}°C`)
})

Callback uruchomi się, gdy zmieni się którekolwiek ze źródeł. Jeśli zmienił się tylko tlen, newTemp i oldTemp będą równe. Watcher nie mówi, które źródło ruszyło, więc w razie potrzeby porównaj pary samodzielnie.

Watch na Getter

Obiekt z reactive wymaga ostrożności. Zapis watch(reactor.temperature, callback) nie zadziała, bo przekazujesz w ten sposób liczbę 2500, a nie reaktywne źródło, i Vue ostrzeże o nieprawidłowym źródle. Właściwość obiektu obserwujesz przez getter, czyli funkcję () => reactor.temperature, którą Vue wywołuje, żeby odczytać aktualną wartość.

import { reactive, watch } from 'vue'

const reactor = reactive({
  name: 'Plasma Core Alpha',
  temperature: 2500
})

// Watch na getter (funkcję)
watch(
  () => reactor.temperature,
  (newTemp) => {
    console.log('Nowa temperatura reaktora:', newTemp)
    if (newTemp > 5000) {
      console.warn('CRITICAL: Temperature exceeds safe limits!')
    }
  }
)

// Watch na głęboki obiekt
watch(
  () => reactor,
  (newReactor) => {
    console.log('Reactor config changed:', newReactor)
  },
  { deep: true }
)

Pierwszy watcher reaguje wyłącznie na temperaturę - zmiana nazwy reaktora go nie obudzi. Drugi obserwuje getter zwracający cały obiekt, dlatego potrzebuje { deep: true }. Bez tej opcji nie zareagowałby na zmianę żadnego pola, bo getter bez deep budzi watcher tylko wtedy, gdy zwraca inną wartość niż poprzednio, a tu zwraca stale ten sam obiekt. Obiekt z reactive przekazany bezpośrednio, bez gettera, tworzy watcher głęboki automatycznie. Z ref przechowującym obiekt jest odwrotnie: zmiana zagnieżdżonego pola, np. missionData.value.systems.oxygen, bez deep: true przejdzie niezauważona. Przy takiej zmianie w miejscu nowa i stara wartość wskazują ten sam obiekt, więc ich porównanie niczego nie powie.

Pamiętaj o koszcie: deep przy każdym uruchomieniu przechodzi po wszystkich zagnieżdżonych polach, co na dużych strukturach bywa kosztowne. Od Vue 3.5 możesz ograniczyć głębokość liczbą, np. deep: 2. Polecam jednak najpierw sięgnąć po getter wskazujący konkretne pole - czujnik podpięty do jednego przewodu jest tańszy niż skaner całego modułu. W następnej lekcji poznasz watchEffect, który sam odnajduje swoje źródła.

Pamiętaj: watch to czujnik alarmowy - wskazujesz mu źródło, a on przy każdej zmianie podaje Ci nowy i poprzedni odczyt.

Kod do tej lekcji: App.vue
<script setup>
import { ref, watch } from 'vue'

// NOVA LAB - System Monitoring with watch()
const oxygenLevel = ref(95)
const powerLevel = ref(2800)
const waterLevel = ref(85)
const logs = ref([])

// watch() - reacts to specific source changes
watch(oxygenLevel, (newValue, oldValue) => {
  const timestamp = new Date().toLocaleTimeString()
  logs.value.unshift({
    time: timestamp,
    type: 'oxygen',
    message: `Oxygen: ${oldValue}% → ${newValue}%`,
    color: newValue < 80 ? '#ff0044' : '#00ff88'
  })

  if (newValue < 80) {
    logs.value.unshift({
      time: timestamp,
      type: 'warning',
      message: 'WARNING: Low oxygen level detected!',
      color: '#ffaa00'
    })
  }
})

watch(powerLevel, (newValue, oldValue) => {
  const timestamp = new Date().toLocaleTimeString()
  logs.value.unshift({
    time: timestamp,
    type: 'power',
    message: `Power: ${oldValue}W → ${newValue}W`,
    color: newValue < 2000 ? '#ff0044' : '#00b4d8'
  })

  if (newValue < 2000) {
    logs.value.unshift({
      time: timestamp,
      type: 'critical',
      message: 'CRITICAL: Power below minimum threshold!',
      color: '#ff0044'
    })
  }
})

// Watch multiple sources
watch([oxygenLevel, powerLevel, waterLevel], ([o2, power, water]) => {
  const allOptimal = o2 > 90 && power > 2500 && water > 80
  if (allOptimal) {
    const timestamp = new Date().toLocaleTimeString()
    logs.value.unshift({
      time: timestamp,
      type: 'success',
      message: 'All systems optimal!',
      color: '#00ff88'
    })
  }
})

function adjustOxygen(delta) {
  oxygenLevel.value = Math.max(0, Math.min(100, oxygenLevel.value + delta))
}

function adjustPower(delta) {
  powerLevel.value = Math.max(0, powerLevel.value + delta)
}

function adjustWater(delta) {
  waterLevel.value = Math.max(0, Math.min(100, waterLevel.value + delta))
}

function clearLogs() {
  logs.value = []
}

function simulateEmergency() {
  oxygenLevel.value = 65
  powerLevel.value = 1500
  waterLevel.value = 45
}

function restoreNominal() {
  oxygenLevel.value = 95
  powerLevel.value = 2800
  waterLevel.value = 85
}
</script>

<template>
  <div class="monitor-system">
    <div class="header">
      <h1>NOVA LAB System Monitor</h1>
      <p class="subtitle">watch() API - Reactive Monitoring</p>
    </div>

    <div class="controls-panel">
      <div class="system-control">
        <h3>Oxygen System</h3>
        <div class="level-bar">
          <div
            class="level-fill oxygen"
            :style="{ width: oxygenLevel + '%' }"
          ></div>
          <span class="level-text">{{ oxygenLevel }}%</span>
        </div>
        <div class="buttons">
          <button @click="adjustOxygen(-10)">-10%</button>
          <button @click="adjustOxygen(-5)">-5%</button>
          <button @click="adjustOxygen(5)">+5%</button>
          <button @click="adjustOxygen(10)">+10%</button>
        </div>
      </div>

      <div class="system-control">
        <h3>Power System</h3>
        <div class="level-bar">
          <div
            class="level-fill power"
            :style="{ width: (powerLevel / 30) + '%' }"
          ></div>
          <span class="level-text">{{ powerLevel }}W</span>
        </div>
        <div class="buttons">
          <button @click="adjustPower(-200)">-200W</button>
          <button @click="adjustPower(-100)">-100W</button>
          <button @click="adjustPower(100)">+100W</button>
          <button @click="adjustPower(200)">+200W</button>
        </div>
      </div>

      <div class="system-control">
        <h3>Water Reserves</h3>
        <div class="level-bar">
          <div
            class="level-fill water"
            :style="{ width: waterLevel + '%' }"
          ></div>
          <span class="level-text">{{ waterLevel }}%</span>
        </div>
        <div class="buttons">
          <button @click="adjustWater(-10)">-10%</button>
          <button @click="adjustWater(-5)">-5%</button>
          <button @click="adjustWater(5)">+5%</button>
          <button @click="adjustWater(10)">+10%</button>
        </div>
      </div>
    </div>

    <div class="scenario-buttons">
      <button @click="simulateEmergency" class="danger">Simulate Emergency</button>
      <button @click="restoreNominal" class="success">Restore Nominal</button>
      <button @click="clearLogs" class="neutral">Clear Logs</button>
    </div>

    <div class="log-panel">
      <h3>System Event Log</h3>
      <div class="log-entries">
        <div
          v-for="(log, index) in logs.slice(0, 15)"
          :key="index"
          class="log-entry"
          :style="{ borderLeftColor: log.color, color: log.color }"
        >
          <span class="log-time">[{{ log.time }}]</span>
          <span class="log-message">{{ log.message }}</span>
        </div>
        <div v-if="logs.length === 0" class="no-logs">
          No events logged yet. Adjust system parameters to see watch() in action!
        </div>
      </div>
    </div>

    <div class="info-box">
      <strong>watch() API:</strong> Monitors specific reactive sources and executes callbacks when they change.
      Perfect for logging, side effects, and conditional responses!
    </div>
  </div>
</template>

<style>
* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
}

body {
  font-family: 'Courier New', monospace;
  background: #0a0e27;
  color: #00ff88;
  padding: 20px;
}

.monitor-system {
  max-width: 1100px;
  margin: 0 auto;
}

.header {
  text-align: center;
  margin-bottom: 30px;
  padding: 20px;
  background: linear-gradient(135deg, #1a1f4c 0%, #0a0e27 100%);
  border: 2px solid #00ff88;
  border-radius: 10px;
}

.header h1 {
  font-size: 2rem;
  margin-bottom: 10px;
  text-shadow: 0 0 20px #00ff88;
}

.subtitle {
  color: #00b4d8;
  font-size: 1.1rem;
}

.controls-panel {
  display: grid;
  gap: 20px;
  margin-bottom: 20px;
}

.system-control {
  background: rgba(0, 180, 216, 0.05);
  border: 2px solid #00b4d8;
  border-radius: 10px;
  padding: 20px;
}

.system-control h3 {
  color: #00b4d8;
  margin-bottom: 15px;
}

.level-bar {
  position: relative;
  height: 40px;
  background: rgba(0, 0, 0, 0.5);
  border: 1px solid #00ff88;
  border-radius: 5px;
  margin-bottom: 15px;
  overflow: hidden;
}

.level-fill {
  height: 100%;
  transition: width 0.3s ease;
}

.level-fill.oxygen {
  background: linear-gradient(90deg, #00ff88, #00cc66);
}

.level-fill.power {
  background: linear-gradient(90deg, #00b4d8, #0088ff);
}

.level-fill.water {
  background: linear-gradient(90deg, #0088ff, #0066cc);
}

.level-text {
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
  font-weight: bold;
  font-size: 1.2rem;
  color: white;
  text-shadow: 0 0 5px black;
}

.buttons {
  display: flex;
  gap: 10px;
  justify-content: center;
}

button {
  background: linear-gradient(135deg, #00b4d8 0%, #0077aa 100%);
  color: white;
  border: none;
  padding: 10px 20px;
  border-radius: 5px;
  cursor: pointer;
  font-family: 'Courier New', monospace;
  font-weight: bold;
  transition: all 0.3s ease;
}

button:hover {
  transform: translateY(-2px);
  box-shadow: 0 5px 15px rgba(0, 180, 216, 0.3);
}

.scenario-buttons {
  display: flex;
  gap: 15px;
  justify-content: center;
  margin-bottom: 20px;
}

.scenario-buttons button {
  padding: 15px 30px;
  font-size: 1rem;
}

.danger {
  background: linear-gradient(135deg, #ff0044 0%, #cc0033 100%) !important;
}

.success {
  background: linear-gradient(135deg, #00ff88 0%, #00cc66 100%) !important;
}

.neutral {
  background: linear-gradient(135deg, #666 0%, #444 100%) !important;
}

.log-panel {
  background: rgba(0, 0, 0, 0.5);
  border: 2px solid #00ff88;
  border-radius: 10px;
  padding: 20px;
  margin-bottom: 20px;
}

.log-panel h3 {
  color: #00ff88;
  margin-bottom: 15px;
}

.log-entries {
  max-height: 300px;
  overflow-y: auto;
}

.log-entry {
  padding: 10px;
  margin-bottom: 8px;
  background: rgba(0, 255, 136, 0.05);
  border-left: 4px solid;
  border-radius: 4px;
  font-size: 0.9rem;
  animation: slideIn 0.3s ease;
}

@keyframes slideIn {
  from {
    opacity: 0;
    transform: translateX(-20px);
  }
  to {
    opacity: 1;
    transform: translateX(0);
  }
}

.log-time {
  opacity: 0.7;
  margin-right: 10px;
}

.no-logs {
  text-align: center;
  padding: 30px;
  color: #666;
  font-style: italic;
}

.info-box {
  background: rgba(0, 255, 136, 0.1);
  border: 2px solid #00ff88;
  border-radius: 10px;
  padding: 15px;
  text-align: center;
  color: #00ff88;
  line-height: 1.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. 1. Do czego służy watch() we Vue.js?

  2. 2. Jakie parametry otrzymuje callback w watch()?

To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Klikanie w kolejności

    Ułóż poprawną składnię watch:

  • Edytor kodu

    Uzupełnij watch obserwujący searchQuery i logujący zmiany z nową i starą wartością.

  • Układanie w pionie

    Ułóż kroki konfiguracji watch w prawidłowej kolejności:

  • Edytor kodu

    Uzupełnij watch z opcją immediate: true do pobrania danych natychmiast po utworzeniu watchera.

  • Układanie w pionie

    Ułóż etapy działania watch od zmiany źródła do callbacku:

  • Układanie w poziomie

    Ułóż watch z opcją deep w prawidłowej kolejności:

  • Edytor kodu

    Uzupełnij watch z { deep: true } do obserwowania zmian w zagnieżdżonym reactive obiekcie.

  1. PytanieCel funkcji watch
  2. PytanieParametry callbacku watch
  3. Kliknij w kolejnościSkładnia watch
  4. Zadanie z kodemPraktyka: Podstawowy watch
  5. PytanieOpcja immediate w watch
  6. Ułóż w kolejnościKonfiguracja watch krok po kroku
  7. Zadanie z kodemPraktyka: Watch z immediate
  8. PytanieOpcja deep w watch
  9. Ułóż w kolejnościEtapy działania watchera
  10. Ułóż w kolejnościWatch z opcjami
  11. Zadanie z kodemPraktyka: Watch deep na obiekcie

Przydatne artykuły