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

Computed i Watch w Praktyce - Systemy Misji

7 min czytania ·
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. 1. Kiedy lepiej użyć computed zamiast watch?

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

  1. PytanieKiedy computed vs watch
  2. PytanieKiedy watch vs computed
  3. PytanieNarzędzie do debugowania reaktywności
  4. Zadanie z kodemPraktyka: Debounced search z watch
  5. PytanieSide effects w computed
  6. Kliknij w kolejnościImport computed i watch
  7. PytaniewatchPostEffect
  8. Ułóż w kolejnościKolejność flush w watch
  9. PytanieWatch na getter function
  10. Ułóż w kolejnościWatch na getter
  11. PytanieKoszt deep watch
  12. Kliknij w kolejnościSkładnia watch na wiele źródeł
  13. Ułóż w kolejnościProces tworzenia computed property
  14. PytanieAsync w watch callback
  15. Ułóż w kolejnościWatch z wieloma źródłami - destrukturyzacja
  16. PytanieDebugowanie computed
  17. PytanieDomyślne wywołanie watch vs watchEffect
  18. Kliknij w kolejnościSkładnia watchEffect z cleanup
  19. Ułóż w kolejnościComputed z walidacją formularza
  20. Ułóż w kolejnościDebounce pattern z watch
  21. Kliknij w kolejnościComputed chain - łańcuch zależności
  22. Ułóż w kolejnościwatchPostEffect składnia

Przydatne artykuły