Kurs Vue.js · Moduł 4: Computed i watch
Zatrzymywanie watcherów - zamykanie kanałów telemetrii
W tej lekcji7
Nocna zmiana w Centrum Obliczeniowym NOVA LAB zostawiła zgłoszenie. Operator zamknął panel sondy Ares-3, przeszedł do panelu reaktora, a dziennik konsoli dalej zapełniał się odczytami ciśnienia z sondy, na którą nikt już nie patrzy. Nikt tego kodu nie wywołuje, a on i tak pracuje.
Tak właśnie zachowuje się watcher. To nie jest funkcja, którą uruchamiasz raz i o której możesz zapomnieć - to otwarty kanał nasłuchu, podpięty do reaktywnego źródła. Dopóki ktoś go nie zamknie, kanał zajmuje pamięć, wykonuje swój callback przy każdej zmianie i potrafi nadpisać dane w panelu przestrojonym dawno temu na inną częstotliwość. Dr. Nova ujmuje to jednym zdaniem: każdy kanał otwarty w Centrum Kontroli musi mieć wyłącznik. W tej lekcji poznasz ten wyłącznik, dowiesz się, kiedy Vue przekręca go za Ciebie, a kiedy musisz zrobić to sam, i nauczysz się sprzątać po robocie, którą watcher zdążył zacząć.
Cykl życia watchera
Zanim sięgniesz po wyłącznik, ustawmy w głowie kolejność zdarzeń, bo bez niej trudno zrozumieć, co właściwie wyłączasz. Watcher przechodzi przez cztery etapy i zawsze w tej samej kolejności.
Etap pierwszy to utworzenie watchera - wywołujesz watch() albo watchEffect(). Etap drugi to rejestracja zależności i nasłuchiwanie zmian: Vue zapamiętuje, które reaktywne źródła zostały odczytane, i podpina się pod nie, tak jak dyżurny wpisuje częstotliwość sondy do konsoli. Etap trzeci to wykonanie callbacku przy zmianie - dopóki kanał jest otwarty, każda zmiana źródła uruchamia Twoją funkcję. Etap czwarty to zatrzymanie, czyli wywołanie stop() albo odmontowanie komponentu.
Etapy drugi i trzeci powtarzają się dowolnie wiele razy, przez cały czas życia panelu. Etap czwarty następuje dokładnie raz i jest nieodwracalny: zatrzymanego watchera nie da się z powrotem włączyć, bo nie ma czegoś takiego jak start(). Jeśli kanał ma znów nadawać, trzeba go otworzyć od nowa, tworząc nowy watcher. Wyjątkiem jest pauza, którą poznasz na końcu lekcji, ale pauza to co innego niż zatrzymanie.
Wyłącznik, który dostajesz w zamian
Skąd wziąć ten wyłącznik? Nie trzeba go szukać - Vue oddaje go w chwili tworzenia kanału. Wywołanie watch() zwraca funkcję, a wywołanie watchEffect() również zwraca funkcję. Nie jest to obiekt obserwatora ani obserwowana wartość, tylko zwykła funkcja bez argumentów, którą przyjęło się nazywać stop function. Dopóki nie zapiszesz jej w zmiennej, wyłącznik wpada w próżnię i kanału nie zamkniesz niczym innym. Poniżej minimalny panel sondy z licznikiem siły sygnału i przyciskiem, który ten kanał zamyka.
<template>
<p>Signal: {{ signalStrength }}</p>
<button @click="signalStrength++">Boost signal</button>
<button @click="stopChannel()">Close channel</button>
</template>
<script setup>
import { ref, watch } from 'vue'
const signalStrength = ref(0)
// watch returns a stop function - keep it in a variable
const stopChannel = watch(signalStrength, (value) => {
console.log('Signal:', value)
})
</script>Klikaj pierwszy przycisk i patrz w konsolę: przy każdym kliknięciu pojawia się nowa linia. Kliknij drugi przycisk i klikaj pierwszy dalej - konsola milczy. Teraz najważniejsze, czyli to, co się nie zmieniło. Licznik signalStrength nadal jest reaktywny, akapit w szablonie nadal pokazuje aktualną liczbę, a przycisk nadal ją zwiększa. Zatrzymanie watchera nie unieważnia danych ani nie zamraża widoku - gaśnie wyłącznie nasłuch. W tym panelu to jedyna rzecz, którą stopChannel() robi, i jednocześnie jedyny sposób, w jaki watcher da się wyłączyć ręcznie.
Warto od razu wyprostować trzy nieporozumienia, bo krążą po zespołach przechodzących na Vue z innych narzędzi. Po pierwsze, nie istnieje żadna metoda watcher.destroy() - watch() nie zwraca obiektu, na którym można by cokolwiek wywołać, tylko funkcję, więc nie ma tam pola do odwołania się kropką. Po drugie, nieprawdą jest, że watchera nie da się zatrzymać ręcznie - właśnie to zrobiłeś jedną linijką. Po trzecie, restart komponentu owszem usuwa jego watchery i za chwilę to wykorzystamy, ale wymuszanie przeładowania całego panelu po to, żeby uciszyć jeden kanał, przypomina odcięcie zasilania modułu w celu zgaszenia jednej kontrolki: zadziała i przy okazji zniszczy cały stan panelu.
Vue zamyka kanały za Ciebie
Zanim zaczniesz odruchowo zapisywać uchwyt przy każdym watcherze, dobra wiadomość: w większości przypadków nie musisz. Watcher utworzony synchronicznie w <script setup> zostaje przypisany do instancji komponentu, w której powstał. Gdy komponent jest odmontowywany, czyli znika ze strony (unmount), Vue zatrzymuje wszystkie należące do niego watchery. Panel sondy gaśnie razem ze swoimi kanałami i żaden z nich nie zostaje otwarty w tle.
Zapamiętaj ten moment dokładnie, bo łatwo o pomyłkę. Watchery nie zatrzymują się po pierwszym wywołaniu callbacku - takie zachowanie musisz zamówić osobno opcją once: true, dostępną od Vue 3.4, którą widziałeś przy opcjach watch. Nie zatrzymują się też po czasie bezczynności - Vue niczego nie odlicza i nie ma żadnego limitu minuty ani innego zegara wygaszającego. I na pewno nie jest tak, że trzeba je zawsze zatrzymywać ręcznie, bo wtedy każdy nieuważny komponent zostawiałby po sobie wyciek pamięci.
Jest jednak wyjątek i to on odpowiada za zgłoszenie z nocnej zmiany. Przypisanie do komponentu działa tylko dla watcherów tworzonych synchronicznie, czyli w chwili, gdy Vue wykonuje kod <script setup>. Watcher powołany później - w setTimeout, w odpowiedzi na zdarzenie albo po await w funkcji asynchronicznej - powstaje już poza tym oknem i nie ma właściciela. Poniżej dwa kanały o identycznej treści, różniące się wyłącznie momentem otwarcia.
<script setup>
import { ref, watchEffect } from 'vue'
const pressure = ref(1013)
// created synchronously in setup - owned by this component
watchEffect(() => {
console.log('Pressure:', pressure.value)
})
setTimeout(() => {
// created one second later - nobody owns this one
watchEffect(() => {
console.log('Delayed pressure:', pressure.value)
})
}, 1000)
</script>Oba watchery są prawdziwymi watcherami: oba śledzą pressure tak samo, oba wykonają swój callback natychmiast po utworzeniu i przy każdej kolejnej zmianie. Różnica ujawnia się dopiero przy zamknięciu panelu. Pierwszy kanał gaśnie razem z komponentem. Drugi nadaje dalej, trzymając przy okazji przy życiu wszystko, do czego się odwołuje - to jest właśnie wyciek pamięci i dokładnie ta linia w dzienniku, której dyżurny nie potrafił wyjaśnić.
Skoro Vue nie zamknie takiego kanału, musimy zrobić to sami. Uchwyt zwrócony przez watchEffect() trzeba przechować w zmiennej widocznej poza funkcją zwrotną, a samo wyłączenie podpiąć pod hook onUnmounted, czyli funkcję z rodziny hooków cyklu życia, którą Vue wywołuje tuż po usunięciu komponentu ze strony.
<script setup>
import { ref, watchEffect, onUnmounted } from 'vue'
const pressure = ref(1013)
let stopDelayed = null
setTimeout(() => {
stopDelayed = watchEffect(() => {
console.log('Delayed pressure:', pressure.value)
})
}, 1000)
onUnmounted(() => {
if (stopDelayed) {
stopDelayed()
}
})
</script>Zmienna stopDelayed jest deklarowana przez let, a nie przez const, bo uchwyt wpada do niej dopiero po odliczeniu sekundy. Z tego samego powodu potrzebny jest warunek: gdy operator zamknie panel wcześniej, niż zadziała setTimeout, zmienna wciąż trzyma null i wywołanie jej jako funkcji rzuciłoby błąd. Poza tym w tym bloku nie zmieniło się nic - watcher śledzi te same dane i wykonuje ten sam callback, doszedł wyłącznie plan awaryjny na wypadek zniknięcia panelu.
Przy okazji rozbrójmy wzorzec, który spotkasz w starszym kodzie: tworzenie zwykłego watchera w onMounted i ręczne zatrzymywanie go w onUnmounted. Hook onMounted wykonuje się przy aktywnym komponencie, więc taki watcher w bieżących wersjach Vue i tak dostaje właściciela i zostaje zatrzymany automatycznie. Ręczne wywołanie stop() niczego tam nie psuje, bo powtórne zatrzymanie już zatrzymanego watchera nic nie robi, ale też niczego nie ratuje. Przed wyciekiem chroni Cię zapamiętanie uchwytu dla kanałów otwieranych asynchronicznie, a nie sam fakt sprzątania w onUnmounted.
Watcher, który wyłącza się sam
Jest jeszcze trzecia sytuacja, obok wyłącznika pod przyciskiem i sprzątania przy odmontowaniu. Czasem kanał ma z góry określone zadanie: czekamy na jeden konkretny stan i po jego wykryciu nasłuch przestaje mieć sens. Stacja odbiera pakiety telemetrii z łazika, a nas interesuje wyłącznie moment, w którym pakiet zostanie skompletowany. Watcher może wtedy zamknąć się własnym uchwytem, wywołując go z wnętrza swojego callbacku.
<script setup>
import { ref, watch } from 'vue'
const telemetry = ref(null)
const stopWhenComplete = watch(telemetry, (packet) => {
if (packet && packet.complete) {
console.log('Telemetry complete - closing channel')
stopWhenComplete()
}
})
</script>Wygląda to jak wąż gryzący własny ogon, ale jest całkowicie bezpieczne. W chwili wywołania watch() callback jeszcze się nie wykonuje - Vue tylko rejestruje zależności. Zanim dojdzie do pierwszej zmiany telemetry, stała stopWhenComplete jest już zainicjalizowana i wskazuje na gotowy uchwyt. Warunek w środku sprawdza dwie rzeczy naraz: czy pakiet w ogóle przyszedł, bo początkową wartością jest null, oraz czy ma ustawioną flagę complete. Po zamknięciu kanału telemetry nadal można podmieniać dowolnie wiele razy - reaktywność działa, po prostu nikt jej już nie słucha.
Jedna pułapka, której lepiej nie odkrywać samodzielnie w produkcyjnym panelu. Gdy dopiszesz do takiego watchera opcję immediate: true, callback wykona się natychmiast, jeszcze w trakcie wywołania watch(), czyli zanim stała zdąży dostać wartość - odwołanie do stopWhenComplete rzuci wtedy błąd o użyciu zmiennej przed inicjalizacją. Jeśli watcher ma zareagować dokładnie raz i zniknąć, polecam zamiast samozatrzymywania użyć opcji once: true z Vue 3.4: intencja jest widoczna od razu w opcjach, a Vue samo zamyka kanał po pierwszym wywołaniu. Ręczne samozatrzymanie zostaw do przypadków z warunkiem, tak jak flaga complete powyżej.
onCleanup, czyli sprzątanie przerwanej roboty
Do tej pory zamykaliśmy kanał, który nic po sobie nie zostawiał. W praktyce watchery uruchamiają robotę trwającą w czasie: pobieranie danych z serwera, odliczanie interwału, nasłuch WebSocketu. Wyobraź sobie panel, który przy każdej zmianie numeru sondy startuje odpytywanie co sekundę. Operator przeskakuje przez trzy sondy, callback wykonuje się trzy razy i po chwili w tle tykają trzy niezależne interwały, choć oglądany jest tylko jeden panel.
Vue daje na to jeden mechanizm i jest on wbudowany w sam callback. Funkcja przekazywana do watch() może przyjąć trzeci argument, nazywany zwyczajowo onCleanup. To funkcja, którą wywołujesz wewnątrz callbacku, podając jej własną funkcję sprzątającą. Vue zapamięta ją i wywoła w dwóch momentach: tuż przed kolejnym uruchomieniem callbacku oraz w chwili zatrzymania watchera. Kolejność argumentów jest sztywna, więc onCleanup zawsze stoi na trzeciej pozycji, po nowej i starej wartości.
<script setup>
import { ref, watch } from 'vue'
const probeId = ref(1)
watch(probeId, (newId, oldId, onCleanup) => {
const timer = setInterval(() => {
console.log('Polling probe', newId)
}, 1000)
onCleanup(() => {
clearInterval(timer)
console.log('Polling stopped for probe', newId)
})
})
</script>Przełącz sondę kilka razy i policz linie w konsoli: w danej chwili odpytywana jest zawsze dokładnie jedna sonda, bo przed każdym nowym uruchomieniem Vue kasuje poprzedni interwał. Zauważ, czego onCleanup nie robi. Nie pomija żadnego uruchomienia callbacku - watcher reaguje na każdą zmianę tak samo jak wcześniej. Nie zatrzymuje też watchera, bo sprzątanie i zamykanie kanału to dwie różne operacje. Zwróć również uwagę na kolejność: Vue uruchamia funkcję sprzątającą, zanim callback ruszy po raz kolejny, więc stary interwał gaśnie, zanim powstanie nowy. Sprzątanie sięga przy tym po timer z tego samego przebiegu, w którym zostało zarejestrowane - każde wywołanie callbacku ma swój komplet zmiennych i sprząta wyłącznie po sobie.
Skoro sprzątanie ma tylko jedną poprawną formę, wyliczmy pomysły, które nie zadziałają. Zwrócenie funkcji sprzątającej z callbacku, jak w useEffect znanym z Reacta, jest w Vue martwym kodem - wartość zwracana przez callback watchera jest ignorowana, a przy callbacku asynchronicznym i tak byłaby to obietnica, nie funkcja. Nie ma również żadnej globalnej funkcji useCleanup() - przedrostek use w ekosystemie Vue oznacza composable, czyli funkcję pisaną przez Ciebie, a nie element API frameworka. Nieprawdą jest wreszcie, że watch nie wspiera sprzątania: wspiera je dokładnie tak samo jak watchEffect, z jedną różnicą w miejscu argumentu. W watchEffect, które nie dostaje nowej ani starej wartości, onCleanup jest argumentem pierwszym i tak właśnie wyglądał przykład z AbortController w poprzedniej lekcji. W watch jest trzeci.
Uchwyt i sprzątanie w jednym panelu
Połączmy oba narzędzia, bo w prawdziwym panelu misji występują razem. Kanał synchronizacji pobiera odczyt wybranej sondy z serwera, operator ma przycisk do wyłączenia synchronizacji, a każde przełączenie sondy musi anulować zapytanie, które jeszcze nie wróciło. Do anulowania posłuży AbortController - przeglądarkowy obiekt, który wystawia pole signal przekazywane do fetch oraz metodę abort() przerywającą trwające zapytanie. Przerwany fetch odrzuca obietnicę błędem o nazwie AbortError, więc ten jeden przypadek wyciszamy, bo nie jest awarią, tylko potwierdzeniem, że sprzątanie zadziałało.
<template>
<p>Probe: {{ probeId }}</p>
<button @click="probeId++">Next probe</button>
<button @click="stopSync()">Stop sync</button>
</template>
<script setup>
import { ref, watch } from 'vue'
const probeId = ref(1)
const reading = ref(null)
const stopSync = watch(probeId, async (newId, oldId, onCleanup) => {
const controller = new AbortController()
onCleanup(() => controller.abort())
try {
const response = await fetch(`/api/nova-lab/probes/${newId}`, {
signal: controller.signal
})
reading.value = await response.json()
} catch (error) {
if (error.name !== 'AbortError') {
throw error
}
}
})
</script>To jest wzorzec, który warto mieć w palcach: najpierw watch(source,, potem callback z trójką argumentów (newVal, oldVal, onCleanup) => {, w pierwszej linii ciała rejestracja sprzątania onCleanup(() => controller.abort()), a na końcu domknięcie }). Rejestrację sprzątania stawiaj od razu po utworzeniu kontrolera, przed pierwszym await - inaczej szybkie przełączenie sondy trafi w okno, w którym zapytanie już leci, a Vue nie wie jeszcze, jak je przerwać. Argument oldId zostaje w podpisie, mimo że go nie używamy, bo pozycji w liście argumentów nie da się przeskoczyć.
Zwróć teraz uwagę na najciekawszy efekt tego połączenia. Kliknięcie przycisku wyłączającego wywołuje stopSync(), a Vue przy zatrzymywaniu watchera uruchamia ostatnią zarejestrowaną funkcję sprzątającą - trwające zapytanie zostaje anulowane, choć nikt nie prosił o to osobno. Zamknięcie kanału zabiera więc ze sobą robotę, którą kanał zdążył zlecić. Nie zmienia natomiast wartości reading: dane pobrane wcześniej zostają w panelu, a jedyne, co znika, to gotowość do reagowania na kolejne przełączenia sondy.
Pauza zamiast wyłącznika (Vue 3.5+)
Na koniec sytuacja, w której stop() jest zbyt ostatecznym narzędziem. Podczas burzy pyłowej czujnik zapylenia szaleje i zalewa dziennik setkami wpisów. Nie chcemy zamykać kanału, bo za dwadzieścia minut znów będzie potrzebny, a odtwarzanie watchera oznaczałoby powielanie tej samej konfiguracji w dwóch miejscach kodu. Chcemy go wyciszyć. Od Vue 3.5 uchwyt zwracany przez watch() i watchEffect() jest wprawdzie dalej funkcją, którą można wywołać jak dotychczas, ale ma dodatkowo trzy metody: stop, pause i resume. Dzięki temu wolno go rozpakować przez destrukturyzację i sięgnąć po każdą z nich osobno.
import { ref, watch } from 'vue'
const dustLevel = ref(12)
const { stop, pause, resume } = watch(dustLevel, (value) => {
console.log('Dust index:', value)
})
// mute the channel during the storm
pause()
// bring it back
resume()
// close it for good
stop()Kolejność w tym bloku nie jest przypadkowa i warto ją zapamiętać: najpierw utworzenie z destrukturyzacją, potem pauza, potem wznowienie, a zatrzymanie zawsze na końcu, bo po nim żadna z pozostałych metod nie ma już czego obsłużyć. Po pause() watcher istnieje dalej i nadal śledzi dustLevel - zawieszone jest wyłącznie wykonywanie callbacku. Jeśli w czasie pauzy źródło się zmieniło, wywołanie resume() uruchomi callback jeden raz, z aktualną wartością, więc panel nadrobi zaległość zamiast zignorować całą burzę.
Dwie uwagi praktyczne. W wersjach Vue starszych niż 3.5 tych metod po prostu nie ma i jedyne, co dostajesz, to funkcja zatrzymująca - wyciszenie realizuje się wtedy zwykłą flagą sprawdzaną na początku callbacku. I nawet gdy metody są dostępne, pause() nie zastępuje stop(): wstrzymany watcher wciąż zajmuje pamięć i wciąż jest podpięty do źródeł, więc kanał, do którego nie zamierzasz wracać, zamykaj na dobre.
Pamiętaj: watcher to otwarty kanał telemetrii Centrum Kontroli - Vue gasi go razem z panelem, ale kanał otwarty poza kolejnością zamkniesz tylko uchwytem, który sam zdążyłeś zapisać.
Kod do tej lekcji: App.vue
<script setup>
import { ref, watch } from 'vue'
// NOVA LAB - Deep Watching Complex Mission Data
const missionData = ref({
crew: {
commander: 'Sarah Chen',
engineer: 'Marcus Rodriguez',
scientist: 'Dr. Yuki Tanaka',
medic: 'Dr. James Wilson'
},
systems: {
life_support: {
oxygen: 95,
temperature: 22,
humidity: 45
},
power: {
solar: 2800,
battery: 85,
consumption: 2200
},
communication: {
earth_link: true,
satellite: true,
local: true
}
},
inventory: {
food: 450,
water: 3200,
medical: 87,
tools: 95
}
})
const changeLog = ref([])
// Deep watch - detects changes in nested objects
watch(
missionData,
(newVal, oldVal) => {
const timestamp = new Date().toLocaleTimeString()
changeLog.value.unshift({
time: timestamp,
message: 'Mission data updated (deep change detected)',
color: '#00b4d8'
})
},
{ deep: true } // Enable deep watching
)
// Watch specific nested property
watch(
() => missionData.value.systems.life_support.oxygen,
(newVal, oldVal) => {
const timestamp = new Date().toLocaleTimeString()
changeLog.value.unshift({
time: timestamp,
message: `O2: ${oldVal}% → ${newVal}%`,
color: newVal < 80 ? '#ff0044' : '#00ff88'
})
}
)
// Watch with immediate option
watch(
() => missionData.value.systems.power.battery,
(newVal) => {
if (newVal < 30) {
const timestamp = new Date().toLocaleTimeString()
changeLog.value.unshift({
time: timestamp,
message: 'Battery critically low!',
color: '#ff0044'
})
}
},
{ immediate: true } // Run immediately on mount
)
function updateOxygen(delta) {
missionData.value.systems.life_support.oxygen = Math.max(0, Math.min(100,
missionData.value.systems.life_support.oxygen + delta
))
}
function updateBattery(delta) {
missionData.value.systems.power.battery = Math.max(0, Math.min(100,
missionData.value.systems.power.battery + delta
))
}
function updateInventory(item, delta) {
missionData.value.inventory[item] = Math.max(0,
missionData.value.inventory[item] + delta
)
}
function toggleComm(system) {
missionData.value.systems.communication[system] =
!missionData.value.systems.communication[system]
}
function emergencyProtocol() {
missionData.value.systems.life_support.oxygen = 65
missionData.value.systems.power.battery = 25
missionData.value.inventory.food -= 50
missionData.value.inventory.water -= 200
}
function restoreNominal() {
missionData.value.systems.life_support.oxygen = 95
missionData.value.systems.life_support.temperature = 22
missionData.value.systems.life_support.humidity = 45
missionData.value.systems.power.battery = 85
missionData.value.inventory.food = 450
missionData.value.inventory.water = 3200
}
</script>
<template>
<div class="deep-watch">
<div class="header">
<h1>NOVA LAB Mission Control</h1>
<p class="subtitle">Deep Watching & Immediate Execution</p>
</div>
<div class="data-grid">
<div class="data-section crew">
<h3>Crew Roster</h3>
<div class="crew-list">
<div v-for="(name, role) in missionData.crew" :key="role" class="crew-member">
<span class="role">{{ role }}:</span>
<span class="name">{{ name }}</span>
</div>
</div>
</div>
<div class="data-section life-support">
<h3>Life Support</h3>
<div class="system-item">
<span>Oxygen:</span>
<span class="value">{{ missionData.systems.life_support.oxygen }}%</span>
<div class="mini-controls">
<button @click="updateOxygen(-5)">-</button>
<button @click="updateOxygen(5)">+</button>
</div>
</div>
<div class="system-item">
<span>Temperature:</span>
<span class="value">{{ missionData.systems.life_support.temperature }}°C</span>
</div>
<div class="system-item">
<span>Humidity:</span>
<span class="value">{{ missionData.systems.life_support.humidity }}%</span>
</div>
</div>
<div class="data-section power">
<h3>Power Systems</h3>
<div class="system-item">
<span>Solar:</span>
<span class="value">{{ missionData.systems.power.solar }}W</span>
</div>
<div class="system-item">
<span>Battery:</span>
<span class="value" :style="{
color: missionData.systems.power.battery < 30 ? '#ff0044' : '#00ff88'
}">
{{ missionData.systems.power.battery }}%
</span>
<div class="mini-controls">
<button @click="updateBattery(-10)">-</button>
<button @click="updateBattery(10)">+</button>
</div>
</div>
<div class="system-item">
<span>Consumption:</span>
<span class="value">{{ missionData.systems.power.consumption }}W</span>
</div>
</div>
<div class="data-section comms">
<h3>Communications</h3>
<div class="comm-status">
<div
v-for="(status, system) in missionData.systems.communication"
:key="system"
class="comm-item"
@click="toggleComm(system)"
>
<span>{{ system.replace('_', ' ') }}:</span>
<span
class="status-indicator"
:class="{ active: status }"
>
{{ status ? 'ONLINE' : 'OFFLINE' }}
</span>
</div>
</div>
</div>
<div class="data-section inventory">
<h3>Inventory</h3>
<div class="inventory-item" v-for="(amount, item) in missionData.inventory" :key="item">
<span>{{ item }}:</span>
<span class="value">{{ amount }}</span>
<div class="mini-controls">
<button @click="updateInventory(item, -10)">-</button>
<button @click="updateInventory(item, 10)">+</button>
</div>
</div>
</div>
</div>
<div class="action-bar">
<button @click="emergencyProtocol" class="emergency">Emergency Protocol</button>
<button @click="restoreNominal" class="restore">Restore Nominal</button>
</div>
<div class="log-section">
<h3>Deep Watch Change Log</h3>
<div class="log-container">
<div
v-for="(log, index) in changeLog.slice(0, 12)"
:key="index"
class="log-entry"
:style="{ color: log.color }"
>
<span class="log-time">[{{ log.time }}]</span> {{ log.message }}
</div>
<div v-if="changeLog.length === 0" class="no-logs">
Modify any nested property to see deep watching in action...
</div>
</div>
</div>
<div class="info-box">
<strong>Deep Watching:</strong> Use <code>{ deep: true }</code> to watch nested object changes.
Use <code>{ immediate: true }</code> to run the watcher immediately on mount!
</div>
</div>
</template>
<style>
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
body {
font-family: 'Courier New', monospace;
background: #0a0e27;
color: #00ff88;
padding: 20px;
}
.deep-watch {
max-width: 1200px;
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;
}
.data-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
gap: 20px;
margin-bottom: 20px;
}
.data-section {
background: rgba(0, 180, 216, 0.05);
border: 2px solid #00b4d8;
border-radius: 10px;
padding: 20px;
}
.data-section h3 {
color: #00b4d8;
margin-bottom: 15px;
font-size: 1.1rem;
}
.crew-list {
display: flex;
flex-direction: column;
gap: 10px;
}
.crew-member {
padding: 10px;
background: rgba(0, 255, 136, 0.05);
border-radius: 5px;
}
.role {
color: #00b4d8;
text-transform: capitalize;
margin-right: 10px;
}
.name {
color: #00ff88;
font-weight: bold;
}
.system-item,
.inventory-item {
display: flex;
justify-content: space-between;
align-items: center;
padding: 10px;
margin-bottom: 8px;
background: rgba(0, 255, 136, 0.05);
border-radius: 5px;
}
.value {
color: #00ff88;
font-weight: bold;
}
.mini-controls {
display: flex;
gap: 5px;
}
.mini-controls button {
background: #00b4d8;
color: white;
border: none;
padding: 5px 12px;
border-radius: 3px;
cursor: pointer;
font-family: 'Courier New', monospace;
font-weight: bold;
}
.mini-controls button:hover {
background: #00ff88;
}
.comm-status {
display: flex;
flex-direction: column;
gap: 10px;
}
.comm-item {
display: flex;
justify-content: space-between;
padding: 10px;
background: rgba(0, 255, 136, 0.05);
border-radius: 5px;
cursor: pointer;
transition: all 0.3s ease;
}
.comm-item:hover {
background: rgba(0, 255, 136, 0.1);
}
.status-indicator {
font-weight: bold;
}
.status-indicator.active {
color: #00ff88;
}
.action-bar {
display: flex;
gap: 20px;
justify-content: center;
margin-bottom: 20px;
}
.action-bar button {
padding: 15px 40px;
font-size: 1rem;
border: none;
border-radius: 8px;
cursor: pointer;
font-family: 'Courier New', monospace;
font-weight: bold;
transition: all 0.3s ease;
}
.emergency {
background: linear-gradient(135deg, #ff0044 0%, #cc0033 100%);
color: white;
}
.restore {
background: linear-gradient(135deg, #00ff88 0%, #00cc66 100%);
color: white;
}
.action-bar button:hover {
transform: translateY(-2px);
box-shadow: 0 5px 20px rgba(0, 255, 136, 0.3);
}
.log-section {
background: rgba(0, 0, 0, 0.5);
border: 2px solid #00ff88;
border-radius: 10px;
padding: 20px;
margin-bottom: 20px;
}
.log-section h3 {
color: #00ff88;
margin-bottom: 15px;
}
.log-container {
max-height: 250px;
overflow-y: auto;
}
.log-entry {
padding: 8px;
margin-bottom: 5px;
background: rgba(0, 255, 136, 0.05);
border-radius: 4px;
font-size: 0.9rem;
animation: slideIn 0.3s ease;
}
@keyframes slideIn {
from {
opacity: 0;
transform: translateX(-10px);
}
to {
opacity: 1;
transform: translateX(0);
}
}
.log-time {
opacity: 0.7;
}
.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;
}
code {
background: rgba(0, 0, 0, 0.3);
padding: 2px 8px;
border-radius: 3px;
color: #00b4d8;
}
</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. Jak zatrzymać watcher we Vue.js?
2. Jak wykonać cleanup (czyszczenie zasobów) w watcherze?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Ułóż cykl życia watchera od utworzenia do zatrzymania:
- Edytor kodu
Uzupełnij kod - zapisz stop function i użyj onCleanup do anulowania poprzedniego requestu.
- Klikanie w kolejności
Ułóż watch z onCleanup w prawidłowej kolejności:
- Układanie w poziomie
Ułóż operacje na watcherze w kolejności: utworzenie, pauzowanie, wznowienie, zatrzymanie:
- Układanie w pionie
Ułóż etapy zatrzymywania watchera i czyszczenia zasobów:
- Edytor kodu
Uzupełnij watch, który zatrzymuje się sam po spełnieniu warunku (np. dane kompletne).
Zadania po tej lekcji
- PytanieZatrzymanie watchera
- Ułóż w kolejnościCykl życia watchera
- PytanieCleanup w watch
- Zadanie z kodemPraktyka: Stop i cleanup watchera
- Kliknij w kolejnościSkładnia watch z cleanup
- PytanieAutomatyczne zatrzymanie watcherów
- Ułóż w kolejnościPauzowanie watchera (Vue 3.5+)
- Ułóż w kolejnościKolejność zatrzymywania watcherów
- Zadanie z kodemPraktyka: Warunkowe zatrzymanie watchera