Kurs Vue.js · Moduł 4: Computed i watch
Computed i Watch w Praktyce - Systemy Misji
W tej lekcji4
Centrum Kontroli zamówiło trzy panele: wyszukiwarkę modułów, która nie zasypuje serwera zapytaniem po każdej literze, kalkulator trajektorii z historią obliczeń i formularz rejestracji z walidacją. Każdy łączy computed z watcherem, a cała sztuka polega na tym, by nie pomylić ról. Zasada jest krótka: gdy potrzebujesz wartości, pisz computed, a gdy potrzebujesz akcji - zapytania, wpisu do dziennika, timera - pisz watch. Getter computed musi przy tym pozostać czysty: tylko liczy i zwraca wynik, nie wysyła zapytań, nie zapisuje do localStorage i nie zmienia innych danych.
System Wyszukiwania Modułów z Debounce
Operator wpisujący słowo "reaktor" wysłałby siedem zapytań, choć interesuje go tylko ostatnie. Technika debounce wstrzymuje akcję, dopóki dane nie przestaną się zmieniać przez określony czas, tu przez 300 milisekund. Zacznijmy od szablonu z polem wyszukiwania, komunikatem ładowania i listą wyników.
<template>
<div class="module-search-system" style="background: #0a0e27; color: #00ff88;">
<input v-model="searchInput" placeholder="Szukaj modułów..." style="background: #1a1e37; color: #00ff88;" />
<p v-if="isLoading" style="color: #00b4d8;">Skanowanie bazy NOVA LAB...</p>
<ul>
<li v-for="item in results" :key="item.id" style="border-bottom: 1px solid #00b4d8;">
{{ item.name }}
</li>
</ul>
</div>
</template>Pole jest podpięte do searchInput, czyli surowego tekstu, który zmienia się po każdym naciśnięciu klawisza. Lista czyta results, a komunikat pokazuje się, gdy isLoading ma wartość true. Teraz skrypt z pierwszym watcherem, który opóźnia przepisanie tekstu do searchQuery.
<script setup>
import { ref, watch } from 'vue'
const searchInput = ref('')
const searchQuery = ref('')
const results = ref([])
const isLoading = ref(false)
// Debounce - opóźnij wyszukiwanie
let debounceTimeout
watch(searchInput, (value) => {
clearTimeout(debounceTimeout)
debounceTimeout = setTimeout(() => {
searchQuery.value = value
}, 300)
})Kolejność kroków warto zapamiętać: zmienna debounceTimeout poza watcherem, potem watch(searchInput, ...), w nim clearTimeout kasujący poprzednie odliczanie i setTimeout ustawiający nowe. Każdy klawisz zeruje zegar, więc do searchQuery trafia dopiero tekst, po którym nastąpiła przerwa. Pole na ekranie nadal pokazuje litery od razu, czeka wyłącznie wyszukiwanie. Drugi watcher wykonuje właściwe zapytanie.
// Wykonaj wyszukiwanie
watch(searchQuery, async (query) => {
if (!query) {
results.value = []
return
}
isLoading.value = true
try {
const response = await fetch(`/api/nova-lab/modules?q=${query}`)
results.value = await response.json()
} finally {
isLoading.value = false
}
})
</script>Callback jest asynchroniczny, a blok try/finally gwarantuje, że isLoading wróci do false nawet po błędzie sieci. Asynchroniczność ma jednak cenę: jeśli starsze zapytanie wróci później niż nowsze, nadpisze świeże wyniki. W produkcyjnym panelu dodaj tu więc sprzątanie z onCleanup i AbortController, tak jak w lekcji o zatrzymywaniu watcherów.
Kalkulator Trajektorii z Historią
Drugi panel liczy wynik działania na prędkości i czasie oraz prowadzi historię obliczeń. Wynik to wartość, więc trafia do computed, a wpis w historii to akcja, więc trafia do watchera. Szablon zawiera dwa pola liczbowe, listę z działaniem i historię.
<template>
<div class="trajectory-calc" style="background: #0a0e27; color: #00ff88;">
<label>Prędkość (km/s):</label>
<input v-model.number="velocity" type="number" style="background: #1a1e37; color: #00ff88;" />
<label>Operacja:</label>
<select v-model="operation" style="background: #1a1e37; color: #00ff88;">
<option value="+">Dodaj</option>
<option value="-">Odejmij</option>
<option value="*">Mnóż</option>
<option value="/">Dziel</option>
</select>
<label>Czas (s):</label>
<input v-model.number="time" type="number" style="background: #1a1e37; color: #00ff88;" />
<p style="color: #00b4d8;">= {{ result }}</p>
<h3>Historia obliczeń:</h3>
<ul>
<li v-for="(entry, i) in history" :key="i" style="color: #00b4d8;">{{ entry }}</li>
</ul>
</div>
</template>Pola używają v-model.number, więc do zmiennych trafiają liczby, a nie tekst, a lista history renderuje wpisy pod wynikiem. Pierwsza część skryptu to stan panelu i computed z wynikiem.
<script setup>
import { ref, computed, watch } from 'vue'
const velocity = ref(25)
const time = ref(3600)
const operation = ref('*')
const history = ref([])
const result = computed(() => {
switch (operation.value) {
case '+': return velocity.value + time.value
case '-': return velocity.value - time.value
case '*': return velocity.value * time.value
case '/': return time.value !== 0 ? velocity.value / time.value : 'Error'
default: return 0
}
})Instrukcja switch wybiera działanie, a przy dzieleniu przez zero computed zwraca napis Error zamiast nieskończoności. Druga część skryptu dopisuje wyniki do historii.
// Zapisuj do historii obliczeń
watch(result, (newResult) => {
const entry = `${velocity.value} ${operation.value} ${time.value} = ${newResult}`
history.value.unshift(entry)
// Ogranicz do 10 wpisów
if (history.value.length > 10) {
history.value.pop()
}
})
</script>Watcher obserwuje computed result, bo computed jest pełnoprawnym źródłem dla watch. Metoda unshift dopisuje wpis na początek tablicy, a pop usuwa najstarszy, gdy wpisów jest więcej niż 10. Zwróć uwagę na rzecz nieoczywistą: gdy prędkość wynosi 0, zmiana czasu przy mnożeniu nie doda wpisu, bo wynik wciąż wynosi 0, a watcher reaguje tylko na zmianę wartości.
Walidacja Formularza
Trzeci panel to rejestracja z adresem e-mail i hasłem. Tu wystarczą same computed, bo każdy komunikat i stan przycisku to wartość wyliczona z tego, co wpisał użytkownik. Szablon wiąże pola, pokazuje błędy i blokuje przycisk.
<template>
<form @submit.prevent="submit">
<div>
<input v-model="email" placeholder="Email" />
<span v-if="emailError" class="error">{{ emailError }}</span>
</div>
<div>
<input v-model="password" type="password" placeholder="Hasło" />
<div class="strength" :class="passwordStrengthClass">
Siła hasła: {{ passwordStrength }}
</div>
</div>
<button :disabled="!isFormValid">Zarejestruj</button>
</form>
</template>Przycisk dostaje :disabled="!isFormValid", więc odblokuje się sam, gdy formularz stanie się poprawny, a :class przełącza wygląd wskaźnika siły hasła. Pierwsza część skryptu definiuje pola i dwa computed z komunikatami.
<script setup>
import { ref, computed } from 'vue'
const email = ref('')
const password = ref('')
const emailError = computed(() => {
if (!email.value) return ''
const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
return regex.test(email.value) ? '' : 'Nieprawidłowy email'
})
const passwordStrength = computed(() => {
const pwd = password.value
if (pwd.length < 6) return 'Słabe'
if (pwd.length < 10) return 'Średnie'
if (/[A-Z]/.test(pwd) && /[0-9]/.test(pwd)) return 'Silne'
return 'Średnie'
})emailError najpierw sprawdza, czy pole jest puste, bo pusty formularz nie powinien krzyczeć błędem, zanim użytkownik zacznie pisać. Potem wyrażenie regularne testuje, czy adres ma postać "coś@coś.coś" bez spacji. passwordStrength ocenia hasło po długości i obecności wielkiej litery oraz cyfry. Druga część skryptu buduje na tych wynikach.
const passwordStrengthClass = computed(() => ({
weak: passwordStrength.value === 'Słabe',
medium: passwordStrength.value === 'Średnie',
strong: passwordStrength.value === 'Silne'
}))
const isFormValid = computed(() => {
return email.value &&
!emailError.value &&
password.value.length >= 6
})
function submit() {
console.log('Formularz wysłany')
}
</script>passwordStrengthClass czyta passwordStrength, a isFormValid czyta emailError - to łańcuch computed, w którym każde ogniwo przelicza się tylko po zmianie ogniwa poprzedniego. Ten sam mechanizm w najprostszej postaci wygląda tak:
const price = ref(100)
const tax = computed(() => price.value * 0.23)
const total = computed(() => price.value + tax.value)Zmiana price unieważnia oba computed, a total przelicza się z nowym podatkiem przy najbliższym odczycie. Łańcuch nie potrzebuje żadnego watchera ani ręcznej synchronizacji.
Debugowanie computed i watcherów
Gdy computed nie przelicza się wtedy, kiedy oczekujesz, zacznij od Vue DevTools. To rozszerzenie przeglądarki, dostępne też jako wtyczka Vite i osobna aplikacja, które pokazuje drzewo komponentów i stan każdego z nich, w tym bieżące wartości ref i computed. Do precyzyjnego śledzenia służą opcje onTrack i onTrigger, przekazywane jako drugi argument computed albo w opcjach watch.
const tax = computed(() => price.value * 0.23, {
onTrack(event) {
console.log('tracked', event.key)
},
onTrigger(event) {
console.log('triggered', event.key, event.newValue)
}
})onTrack wywoła się, gdy getter zarejestruje zależność, a onTrigger, gdy zmiana tej zależności unieważni wynik, o ile computed jest akurat używany, na przykład w szablonie. Obie opcje działają tylko w trybie deweloperskim, więc w wersji produkcyjnej nie kosztują nic. Polecam najpierw DevTools, a onTrack i onTrigger dopiero wtedy, gdy podgląd stanu nie wystarcza. W projekcie modułu połączysz wszystkie te narzędzia w jednym dashboardzie misji.
Pamiętaj: computed odpowiada na pytanie "ile wynosi", a watch na pytanie "co zrobić, gdy się zmieni" - pomyl te role, a panel misji albo liczy za dużo, albo nie reaguje wcale.
Kod do tej lekcji: App.vue
<script setup>
import { ref, watch, watchEffect, onUnmounted } from 'vue'
// NOVA LAB - Advanced Watching: Multiple Sources & Cleanup
const sensorA = ref(75)
const sensorB = ref(82)
const sensorC = ref(91)
const isMonitoring = ref(false)
const alerts = ref([])
const sensorReadings = ref([])
let monitoringInterval = null
// Watch multiple sources
watch([sensorA, sensorB, sensorC], ([a, b, c], [oldA, oldB, oldC]) => {
const timestamp = new Date().toLocaleTimeString()
if (a !== oldA) {
alerts.value.unshift({
time: timestamp,
sensor: 'A',
value: a,
previous: oldA,
color: '#00ff88'
})
}
if (b !== oldB) {
alerts.value.unshift({
time: timestamp,
sensor: 'B',
value: b,
previous: oldB,
color: '#00b4d8'
})
}
if (c !== oldC) {
alerts.value.unshift({
time: timestamp,
sensor: 'C',
value: c,
previous: oldC,
color: '#ffaa00'
})
}
// Calculate average
const avg = Math.round((a + b + c) / 3)
if (avg < 70) {
alerts.value.unshift({
time: timestamp,
sensor: 'SYSTEM',
value: avg,
message: 'Average below threshold!',
color: '#ff0044'
})
}
})
// Watch with cleanup function
watch(isMonitoring, (newValue, oldValue, onCleanup) => {
const timestamp = new Date().toLocaleTimeString()
if (newValue) {
alerts.value.unshift({
time: timestamp,
message: '▶Continuous monitoring started',
color: '#00ff88'
})
// Start interval
monitoringInterval = setInterval(() => {
const reading = {
time: new Date().toLocaleTimeString(),
a: sensorA.value,
b: sensorB.value,
c: sensorC.value,
avg: Math.round((sensorA.value + sensorB.value + sensorC.value) / 3)
}
sensorReadings.value.unshift(reading)
// Simulate sensor fluctuation
sensorA.value = Math.max(0, Math.min(100, sensorA.value + (Math.random() - 0.5) * 2))
sensorB.value = Math.max(0, Math.min(100, sensorB.value + (Math.random() - 0.5) * 2))
sensorC.value = Math.max(0, Math.min(100, sensorC.value + (Math.random() - 0.5) * 2))
}, 2000)
// Cleanup function - called when watcher stops or before re-run
onCleanup(() => {
if (monitoringInterval) {
clearInterval(monitoringInterval)
const stopTime = new Date().toLocaleTimeString()
alerts.value.unshift({
time: stopTime,
message: '⏸Monitoring stopped (cleanup executed)',
color: '#ffaa00'
})
}
})
}
})
// watchEffect for computed average
const avgReading = ref(0)
watchEffect(() => {
avgReading.value = Math.round((sensorA.value + sensorB.value + sensorC.value) / 3)
})
function adjustSensor(sensor, delta) {
if (sensor === 'A') {
sensorA.value = Math.max(0, Math.min(100, sensorA.value + delta))
} else if (sensor === 'B') {
sensorB.value = Math.max(0, Math.min(100, sensorB.value + delta))
} else if (sensor === 'C') {
sensorC.value = Math.max(0, Math.min(100, sensorC.value + delta))
}
}
function toggleMonitoring() {
isMonitoring.value = !isMonitoring.value
}
function resetSensors() {
sensorA.value = 75
sensorB.value = 82
sensorC.value = 91
}
function clearAlerts() {
alerts.value = []
sensorReadings.value = []
}
// Cleanup on unmount
onUnmounted(() => {
if (monitoringInterval) {
clearInterval(monitoringInterval)
}
})
</script>
<template>
<div class="advanced-watch">
<div class="header">
<h1>NOVA LAB Sensor Array</h1>
<p class="subtitle">Multiple Sources & Watch Cleanup</p>
</div>
<div class="monitoring-control">
<button
@click="toggleMonitoring"
:class="{ active: isMonitoring }"
class="monitor-btn"
>
{{ isMonitoring ? '⏸Stop Monitoring' : '▶Start Monitoring' }}
</button>
<div class="status" :class="{ monitoring: isMonitoring }">
{{ isMonitoring ? 'ACTIVE' : 'INACTIVE' }}
</div>
</div>
<div class="sensors-grid">
<div class="sensor-card sensor-a">
<h3>Sensor A</h3>
<div class="sensor-visual">
<div
class="sensor-bar"
:style="{ height: sensorA + '%', background: '#00ff88' }"
></div>
</div>
<div class="sensor-value">{{ sensorA.toFixed(1) }}%</div>
<div class="sensor-controls">
<button @click="adjustSensor('A', -5)">-5</button>
<button @click="adjustSensor('A', 5)">+5</button>
</div>
</div>
<div class="sensor-card sensor-b">
<h3>Sensor B</h3>
<div class="sensor-visual">
<div
class="sensor-bar"
:style="{ height: sensorB + '%', background: '#00b4d8' }"
></div>
</div>
<div class="sensor-value">{{ sensorB.toFixed(1) }}%</div>
<div class="sensor-controls">
<button @click="adjustSensor('B', -5)">-5</button>
<button @click="adjustSensor('B', 5)">+5</button>
</div>
</div>
<div class="sensor-card sensor-c">
<h3>Sensor C</h3>
<div class="sensor-visual">
<div
class="sensor-bar"
:style="{ height: sensorC + '%', background: '#ffaa00' }"
></div>
</div>
<div class="sensor-value">{{ sensorC.toFixed(1) }}%</div>
<div class="sensor-controls">
<button @click="adjustSensor('C', -5)">-5</button>
<button @click="adjustSensor('C', 5)">+5</button>
</div>
</div>
<div class="sensor-card average">
<h3>Average</h3>
<div class="avg-display">{{ avgReading }}%</div>
<div class="avg-status" :style="{
color: avgReading > 80 ? '#00ff88' : avgReading > 60 ? '#ffaa00' : '#ff0044'
}">
{{ avgReading > 80 ? 'OPTIMAL' : avgReading > 60 ? 'CAUTION' : 'CRITICAL' }}
</div>
</div>
</div>
<div class="quick-actions">
<button @click="resetSensors">Reset Sensors</button>
<button @click="clearAlerts">Clear Logs</button>
</div>
<div class="data-panels">
<div class="panel alerts-panel">
<h3>Alert Log</h3>
<div class="panel-content">
<div
v-for="(alert, index) in alerts.slice(0, 10)"
:key="index"
class="alert-item"
:style="{ borderLeftColor: alert.color }"
>
<span class="alert-time">[{{ alert.time }}]</span>
<span v-if="alert.sensor" class="alert-sensor">Sensor {{ alert.sensor }}:</span>
<span v-if="alert.value !== undefined" class="alert-value">
{{ alert.previous !== undefined ? `${alert.previous} → ` : '' }}{{ alert.value }}%
</span>
<span v-if="alert.message" class="alert-message">{{ alert.message }}</span>
</div>
<div v-if="alerts.length === 0" class="no-data">
No alerts yet...
</div>
</div>
</div>
<div class="panel readings-panel">
<h3>Sensor Readings (Auto-capture)</h3>
<div class="panel-content">
<div
v-for="(reading, index) in sensorReadings.slice(0, 8)"
:key="index"
class="reading-item"
>
<span class="reading-time">[{{ reading.time }}]</span>
<span class="reading-data">
A: {{ reading.a.toFixed(1) }}% |
B: {{ reading.b.toFixed(1) }}% |
C: {{ reading.c.toFixed(1) }}% |
Avg: {{ reading.avg }}%
</span>
</div>
<div v-if="sensorReadings.length === 0" class="no-data">
Start monitoring to capture readings...
</div>
</div>
</div>
</div>
<div class="info-box">
<strong>Advanced Watching:</strong> Watch multiple sources with <code>watch([a, b, c], ...)</code>.
Use <code>onCleanup()</code> to clean up side effects like intervals when watcher stops!
</div>
</div>
</template>
<style>
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
body {
font-family: 'Courier New', monospace;
background: #0a0e27;
color: #00ff88;
padding: 20px;
}
.advanced-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;
}
.monitoring-control {
display: flex;
justify-content: center;
align-items: center;
gap: 20px;
margin-bottom: 30px;
}
.monitor-btn {
padding: 15px 40px;
font-size: 1.2rem;
background: linear-gradient(135deg, #00b4d8 0%, #0077aa 100%);
color: white;
border: none;
border-radius: 8px;
cursor: pointer;
font-family: 'Courier New', monospace;
font-weight: bold;
transition: all 0.3s ease;
}
.monitor-btn.active {
background: linear-gradient(135deg, #00ff88 0%, #00cc66 100%);
animation: pulse 2s infinite;
}
@keyframes pulse {
0%, 100% { box-shadow: 0 0 20px rgba(0, 255, 136, 0.5); }
50% { box-shadow: 0 0 40px rgba(0, 255, 136, 0.8); }
}
.status {
font-size: 1.5rem;
font-weight: bold;
color: #666;
}
.status.monitoring {
color: #00ff88;
text-shadow: 0 0 10px #00ff88;
}
.sensors-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
gap: 20px;
margin-bottom: 20px;
}
.sensor-card {
background: rgba(0, 180, 216, 0.05);
border: 2px solid #00b4d8;
border-radius: 10px;
padding: 20px;
text-align: center;
}
.sensor-card h3 {
color: #00b4d8;
margin-bottom: 15px;
}
.sensor-visual {
height: 150px;
background: rgba(0, 0, 0, 0.5);
border: 2px solid #00ff88;
border-radius: 8px;
margin-bottom: 15px;
display: flex;
align-items: flex-end;
justify-content: center;
overflow: hidden;
}
.sensor-bar {
width: 60%;
transition: height 0.3s ease;
border-radius: 5px 5px 0 0;
}
.sensor-value {
font-size: 1.8rem;
font-weight: bold;
color: #00ff88;
margin-bottom: 10px;
}
.sensor-controls {
display: flex;
gap: 10px;
justify-content: center;
}
.sensor-controls button {
background: #00b4d8;
color: white;
border: none;
padding: 8px 15px;
border-radius: 5px;
cursor: pointer;
font-family: 'Courier New', monospace;
font-weight: bold;
}
.average {
grid-column: span 1;
}
.avg-display {
font-size: 3rem;
font-weight: bold;
color: #00ff88;
text-shadow: 0 0 20px #00ff88;
margin: 20px 0;
}
.avg-status {
font-size: 1.2rem;
font-weight: bold;
}
.quick-actions {
display: flex;
gap: 15px;
justify-content: center;
margin-bottom: 20px;
}
.quick-actions button {
padding: 12px 30px;
background: linear-gradient(135deg, #666 0%, #444 100%);
color: white;
border: none;
border-radius: 5px;
cursor: pointer;
font-family: 'Courier New', monospace;
font-weight: bold;
}
.data-panels {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(450px, 1fr));
gap: 20px;
margin-bottom: 20px;
}
.panel {
background: rgba(0, 0, 0, 0.5);
border: 2px solid #00ff88;
border-radius: 10px;
padding: 20px;
}
.panel h3 {
color: #00ff88;
margin-bottom: 15px;
}
.panel-content {
max-height: 300px;
overflow-y: auto;
}
.alert-item,
.reading-item {
padding: 10px;
margin-bottom: 8px;
background: rgba(0, 255, 136, 0.05);
border-radius: 4px;
font-size: 0.9rem;
animation: slideIn 0.3s ease;
}
.alert-item {
border-left: 4px solid;
}
@keyframes slideIn {
from {
opacity: 0;
transform: translateX(-10px);
}
to {
opacity: 1;
transform: translateX(0);
}
}
.alert-time,
.reading-time {
opacity: 0.7;
margin-right: 8px;
}
.alert-sensor {
color: #00b4d8;
font-weight: bold;
margin-right: 5px;
}
.alert-value {
color: #00ff88;
}
.reading-data {
color: #00b4d8;
}
.no-data {
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. Kiedy lepiej użyć computed zamiast watch?
2. Kiedy lepiej użyć watch zamiast computed?
To 2 z 10 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Uzupełnij debounced search używając watch do opóźnienia wysyłania zapytania.
- Klikanie w kolejności
Ułóż poprawny import computed i watch z Vue:
- Układanie w pionie
Ułóż tryby flush watch od najwcześniejszego do najpóźniejszego wykonania:
- Układanie w poziomie
Ułóż watch obserwujący property reactive obiektu:
- Klikanie w kolejności
Ułóż watch obserwujący wiele refs jednocześnie:
- Układanie w pionie
Ułóż kroki tworzenia computed property od początku do końca:
- Układanie w poziomie
Ułóż poprawną destrukturyzację w watch na wiele źródeł:
- Klikanie w kolejności
Ułóż watchEffect z onCleanup w prawidłowej kolejności:
- Układanie w poziomie
Ułóż computed do walidacji email w prawidłowej kolejności:
- Układanie w pionie
Ułóż kroki implementacji debounce z watch od początku do końca:
- Klikanie w kolejności
Ułóż łańcuch computed dependencies od źródła do końcowej wartości:
- Układanie w poziomie
Ułóż poprawne wywołanie watchPostEffect:
Zadania po tej lekcji
- PytanieKiedy computed vs watch
- PytanieKiedy watch vs computed
- PytanieNarzędzie do debugowania reaktywności
- Zadanie z kodemPraktyka: Debounced search z watch
- PytanieSide effects w computed
- Kliknij w kolejnościImport computed i watch
- PytaniewatchPostEffect
- Ułóż w kolejnościKolejność flush w watch
- PytanieWatch na getter function
- Ułóż w kolejnościWatch na getter
- PytanieKoszt deep watch
- Kliknij w kolejnościSkładnia watch na wiele źródeł
- Ułóż w kolejnościProces tworzenia computed property
- PytanieAsync w watch callback
- Ułóż w kolejnościWatch z wieloma źródłami - destrukturyzacja
- PytanieDebugowanie computed
- PytanieDomyślne wywołanie watch vs watchEffect
- Kliknij w kolejnościSkładnia watchEffect z cleanup
- Ułóż w kolejnościComputed z walidacją formularza
- Ułóż w kolejnościDebounce pattern z watch
- Kliknij w kolejnościComputed chain - łańcuch zależności
- Ułóż w kolejnościwatchPostEffect składnia