Kurs Vue.js · Moduł 3: Reaktywność

Debugowanie Reaktywności

4 min czytania ·
W tej lekcji6

Nawet najlepsi inżynierowie NOVA LAB muszą czasem debugować swoje systemy. Poznaj narzędzia do debugowania reaktywności.

"Panel się nie odświeża" to najczęstsze zgłoszenie w dzienniku usterek stacji. Przyczyna prawie zawsze leży w danych: wartość okazuje się zwykłym obiektem zamiast Proxy albo straciła połączenie po destrukturyzacji. Zanim zaczniesz przepisywać komponent, sprawdź, z czym naprawdę pracujesz - Vue ma do tego zestaw testerów diagnostycznych.

isRef() i isReactive()

isRef() zwraca true, gdy wartość jest refem. isReactive() sprawdza, czy obiekt jest Proxy utworzonym przez reactive() lub shallowReactive(). Obie funkcje zwracają wartość logiczną:

import { ref, reactive, isRef, isReactive } from 'vue'

const powerLevel = ref(0)
const reactor = reactive({ name: 'Plasma Core Alpha' })
const plainConfig = { mode: 'safe' }

console.log(isRef(powerLevel))       // true
console.log(isRef(reactor))     // false
console.log(isReactive(reactor)) // true
console.log(isReactive(powerLevel))   // false
console.log(isReactive(plainConfig)) // false

Ref nie jest Proxy, dlatego isReactive(powerLevel) daje false. Obiekt schowany w refie już nim jest: isReactive(ref({}).value) zwróci true. Pokrewne testery to isProxy(), który rozpoznaje każde Proxy Vue, także tylko do odczytu, oraz isReadonly().

unref() - Bezpieczne Rozpakowanie Odczytu

unref(x) to skrót od isRef(x) ? x.value : x. Pozwala napisać funkcję, która przyjmie zarówno ref, jak i zwykłą wartość:

import { ref, unref } from 'vue'

const temperature = ref(2500)
const plainReading = 1500

// unref zwraca .value dla ref, lub wartość bezpośrednio
console.log(unref(temperature))      // 2500
console.log(unref(plainReading)) // 1500

// Przydatne w funkcjach uniwersalnych
function convertToFahrenheit(kelvin) {
  return (unref(kelvin) - 273.15) * 9/5 + 32
}

convertToFahrenheit(temperature)      // 4040.3299999999995 (ok. 4040.33)
convertToFahrenheit(plainReading) // 2240.33

Długi ogon po przecinku to zwykła arytmetyka zmiennoprzecinkowa JavaScriptu, nie wina Vue - do wyświetlenia użyj toFixed(2). Od Vue 3.3 istnieje też toValue(), które działa jak unref(), a dodatkowo wywołuje przekazane gettery.

toRaw() - Surowy Obiekt Sensora

toRaw() zwraca oryginalny obiekt schowany za Proxy. To furtka awaryjna: odczyt przez nią nie jest śledzony, a zapis nie odświeży widoku.

import { reactive, toRaw } from 'vue'

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

const rawReactor = toRaw(reactor)
console.log(rawReactor) // Oryginalny obiekt bez Proxy

// Przydatne do:
// - Porównywania obiektów
// - Przekazywania do API, które nie przyjmują Proxy (np. structuredClone)
// - Bibliotek zewnętrznych

JSON.stringify() radzi sobie z Proxy bez problemu, ale structuredClone() czy postMessage() rzucą błąd DataCloneError - wtedy podaj im toRaw(reactor). Dokumentacja odradza trzymanie trwałej referencji do surowego obiektu, bo łatwo o zmiany, których panel nie zauważy.

markRaw() - Wyłączenie Reaktywności

markRaw() oznacza obiekt tak, że Vue nigdy nie zamieni go w Proxy, i zwraca ten sam obiekt:

import { reactive, markRaw } from 'vue'

const externalSensorLibrary = markRaw({
  hardwareInterface: new Map(),
  calibrate() { /* ... */ }
})

const state = reactive({
  sensor: externalSensorLibrary // Nie będzie reaktywny
})

// Przydatne dla:
// - Bibliotek sprzętowych (sensor drivers, hardware interfaces)
// - Dużych niezmiennych danych z bazy NOVA LAB
// - Obiektów komponentów Vue

isReactive(state.sensor) zwróci false, a state.sensor to dokładnie ten sam obiekt co externalSensorLibrary. Proxy potrafi wręcz zepsuć niektóre klasy z bibliotek: metoda, która sięga do prywatnego pola zapisanego z krzyżykiem, na przykład #points, rzuci wtedy TypeError. markRaw temu zapobiega. Uwaga: oznaczenie dotyczy tylko samego obiektu, nie jego zagnieżdżonych pól.

Debugging z watch

watch(źródło, callback) wywołuje funkcję z nową i starą wartością po każdej zmianie źródła, a opcja immediate: true uruchamia ją od razu. Watchery omówimy w module 4, ale już teraz pomogą w śledztwie:

import { ref, watch } from 'vue'

const count = ref(0)

watch(count, (newValue, oldValue) => {
  console.log(`count changed: ${oldValue} → ${newValue}`)
  console.trace() // Stack trace - skąd przyszła zmiana?
}, { immediate: true })

Pierwszy wpis to count changed: undefined → 0, bo przy starcie nie ma jeszcze starej wartości. console.trace() wypisuje stos wywołań, więc widzisz, która funkcja zmieniła odczyt. W trybie deweloperskim Vue oferuje też opcje onTrack i onTrigger dla watcherów i computed oraz haki onRenderTracked i onRenderTriggered.

Vue DevTools

Vue DevTools to rozszerzenie przeglądarki, dostępne też jako wtyczka do Vite. W Vue DevTools możesz:

  • Zobaczyć wszystkie reaktywne dane
  • Śledzić zmiany w czasie rzeczywistym
  • Edytować wartości na żywo
  • Zobaczyć drzewo zależności

Zakładka komponentów pokazuje drzewo komponentów z ich stanem, Timeline zapisuje zdarzenia i czasy renderowania, a zakładka Graph pokazuje reaktywne zależności wybranego komponentu. Zainstaluj je pierwszego dnia - oszczędzą Ci godzin zgadywania. W następnej lekcji złożysz wszystkie poznane narzędzia w praktyczne panele.

Zapamiętaj: zanim rozkręcisz reaktor, sprawdź go testerem - isRef i isReactive powiedzą Ci, czy przewód w ogóle jest podłączony.

Kod do tej lekcji: App.vue
<script setup>
import { ref, reactive, shallowRef, shallowReactive, readonly, triggerRef } from 'vue'

// Zaawansowana reaktywność - shallow i readonly
// System ochrony danych misji NOVA LAB

// shallowRef - reaktywność tylko na poziomie .value
const missionData = shallowRef({
  id: 'MISSION-2087',
  crew: ['Chen', 'Rodriguez', 'Kim'],
  objectives: {
    primary: 'Establish Mars base',
    secondary: 'Collect samples'
  }
})

// shallowReactive - reaktywność tylko na pierwszym poziomie
const missionStatus = shallowReactive({
  name: 'Mars Colony Alpha',
  phase: 'DEPLOYMENT',
  timeline: {
    start: '2087-03-15',
    current: '2087-06-20',
    estimated_end: '2087-12-31'
  },
  modules: {
    habitation: { status: 'ACTIVE', progress: 75 },
    power: { status: 'ACTIVE', progress: 90 },
    lifesupport: { status: 'TESTING', progress: 60 }
  }
})

// readonly - tylko do odczytu
const criticalParameters = readonly(reactive({
  maxCrewSize: 12,
  minOxygen: 21,
  maxRadiation: 100,
  safetyProtocols: {
    emergency: 'AUTO_SHUTDOWN',
    backup: 'REDUNDANT_SYSTEMS'
  }
}))

// Przykład normalnego ref dla porównania
const normalMissionData = ref({
  id: 'MISSION-2087',
  crew: ['Chen', 'Rodriguez', 'Kim']
})

// Demonstracja shallowRef
function modifyShallowRef() {
  // To NIE zadziała - zmiana głęboko zagnieżdżonej właściwości
  missionData.value.objectives.primary = 'Build greenhouse'
  console.log("Modified nested property, but UI won't update automatically")

  // Musimy ręcznie wywołać triggerRef
  // triggerRef(missionData)
}

function replaceShallowRef() {
  // To ZADZIAŁA - zastąpienie całego .value
  missionData.value = {
    ...missionData.value,
    objectives: {
      primary: 'Build greenhouse',
      secondary: 'Test farming systems'
    }
  }
}

function forceUpdateShallowRef() {
  // Modyfikacja zagnieżdżonej właściwości
  missionData.value.crew.push('Jackson')
  // Ręczne wymuszenie aktualizacji
  triggerRef(missionData)
}

// Demonstracja shallowReactive
function modifyShallowReactive() {
  // To ZADZIAŁA - zmiana na pierwszym poziomie
  missionStatus.phase = 'OPERATIONAL'
}

function modifyDeepShallowReactive() {
  // To NIE ZADZIAŁA automatycznie - zmiana głębiej
  missionStatus.modules.habitation.progress = 100
  console.log("Modified deep property, UI won't update")
}

function replaceNestedShallowReactive() {
  // To ZADZIAŁA - zastąpienie obiektu na pierwszym poziomie
  missionStatus.modules = {
    ...missionStatus.modules,
    habitation: { status: 'COMPLETE', progress: 100 }
  }
}

// Demonstracja readonly
function tryModifyReadonly() {
  try {
    // To NIE ZADZIAŁA - readonly blokuje modyfikacje
    criticalParameters.maxCrewSize = 20
  } catch (e) {
    console.warn('Cannot modify readonly object')
  }
}

// Liczniki dla demonstracji
const shallowRefCounter = ref(0)
const shallowReactiveCounter = ref(0)
const readonlyCounter = ref(0)
</script>

<template>
  <div class="advanced-reactivity">
    <div class="header">
      <h1>SYSTEM OCHRONY DANYCH - NOVA LAB</h1>
      <p class="subtitle">shallowRef(), shallowReactive(), readonly(), triggerRef()</p>
    </div>

    <!-- shallowRef Demo -->
    <div class="demo-section">
      <h2>shallowRef() - Płytka reaktywność</h2>
      <div class="demo-grid">
        <div class="info-card">
          <h3>Charakterystyka</h3>
          <ul>
            <li>Reaktywne tylko na poziomie <code>.value</code></li>
            <li>Zmiany głęboko zagnieżdżonych właściwości NIE wywołują aktualizacji</li>
            <li>Użyj <code>triggerRef()</code> aby wymusić aktualizację</li>
            <li>Wydajniejsze dla dużych obiektów</li>
          </ul>
        </div>

        <div class="data-card">
          <h3>Dane misji (shallowRef)</h3>
          <pre>{{ JSON.stringify(missionData, null, 2) }}</pre>

          <div class="controls">
            <button @click="modifyShallowRef(); shallowRefCounter++" class="btn btn-warning">
              Modyfikuj zagnieżdżone (nie zadziała)
            </button>
            <button @click="replaceShallowRef(); shallowRefCounter++" class="btn btn-success">
              Zastąp .value (zadziała)
            </button>
            <button @click="forceUpdateShallowRef(); shallowRefCounter++" class="btn btn-info">
              Wymuś aktualizację (triggerRef)
            </button>
          </div>

          <div class="counter">
            Liczba akcji: {{ shallowRefCounter }}
          </div>
        </div>
      </div>

      <div class="code-example">
        <h4>Przykład kodu:</h4>
        <pre>const data = shallowRef({ nested: { value: 1 } })

// Nie wywoła aktualizacji UI
data.value.nested.value = 2

// Wywoła aktualizację UI
data.value = { nested: { value: 2 } }

// Wymuś aktualizację po modyfikacji
data.value.nested.value = 2
triggerRef(data)</pre>
      </div>
    </div>

    <!-- shallowReactive Demo -->
    <div class="demo-section">
      <h2>shallowReactive() - Płytka reaktywność obiektów</h2>
      <div class="demo-grid">
        <div class="info-card">
          <h3>Charakterystyka</h3>
          <ul>
            <li>Reaktywne tylko właściwości pierwszego poziomu</li>
            <li>Zagnieżdżone obiekty NIE są reaktywne</li>
            <li>Trzeba zastępować zagnieżdżone obiekty całkowicie</li>
            <li>Wydajne dla płaskich struktur</li>
          </ul>
        </div>

        <div class="data-card">
          <h3>Status misji (shallowReactive)</h3>
          <div class="status-display">
            <p><strong>Nazwa:</strong> {{ missionStatus.name }}</p>
            <p><strong>Faza:</strong>
              <span class="phase-badge">{{ missionStatus.phase }}</span>
            </p>
            <p><strong>Timeline:</strong> {{ missionStatus.timeline.current }}</p>

            <div class="modules-grid">
              <div
                v-for="(module, key) in missionStatus.modules"
                :key="key"
                class="module-card"
              >
                <div class="module-name">{{ key }}</div>
                <div class="module-status">{{ module.status }}</div>
                <div class="progress-bar">
                  <div class="progress-fill" :style="{ width: module.progress + '%' }">
                    {{ module.progress }}%
                  </div>
                </div>
              </div>
            </div>
          </div>

          <div class="controls">
            <button @click="modifyShallowReactive(); shallowReactiveCounter++" class="btn btn-success">
              Zmień fazę (1 poziom)
            </button>
            <button @click="modifyDeepShallowReactive(); shallowReactiveCounter++" class="btn btn-warning">
              Zmień progress (głęboko)
            </button>
            <button @click="replaceNestedShallowReactive(); shallowReactiveCounter++" class="btn btn-success">
              Zastąp moduł
            </button>
          </div>

          <div class="counter">
            Liczba akcji: {{ shallowReactiveCounter }}
          </div>
        </div>
      </div>

      <div class="code-example">
        <h4>Przykład kodu:</h4>
        <pre>const state = shallowReactive({
  count: 0,
  nested: { value: 1 }
})

// Zadziała - pierwszy poziom
state.count = 1

// Nie zadziała - zagnieżdżone
state.nested.value = 2

// Zadziała - zastąpienie
state.nested = { value: 2 }</pre>
      </div>
    </div>

    <!-- readonly Demo -->
    <div class="demo-section">
      <h2>readonly() - Dane tylko do odczytu</h2>
      <div class="demo-grid">
        <div class="info-card">
          <h3>Charakterystyka</h3>
          <ul>
            <li>Całkowita ochrona przed modyfikacją</li>
            <li>Idealny dla stałych konfiguracji</li>
            <li>Zapobiega przypadkowym zmianom</li>
            <li>Wyświetla ostrzeżenia w dev mode</li>
          </ul>
        </div>

        <div class="data-card">
          <h3>Parametry krytyczne (readonly)</h3>
          <div class="critical-params">
            <div class="param-item">
              <span class="param-label">Max załoga:</span>
              <span class="param-value">{{ criticalParameters.maxCrewSize }}</span>
            </div>
            <div class="param-item">
              <span class="param-label">Min tlen (%):</span>
              <span class="param-value">{{ criticalParameters.minOxygen }}</span>
            </div>
            <div class="param-item">
              <span class="param-label">Max radiacja:</span>
              <span class="param-value">{{ criticalParameters.maxRadiation }} mSv</span>
            </div>
            <div class="param-item">
              <span class="param-label">Protokół awaryjny:</span>
              <span class="param-value">{{ criticalParameters.safetyProtocols.emergency }}</span>
            </div>
            <div class="param-item">
              <span class="param-label">System backup:</span>
              <span class="param-value">{{ criticalParameters.safetyProtocols.backup }}</span>
            </div>
          </div>

          <div class="controls">
            <button @click="tryModifyReadonly(); readonlyCounter++" class="btn btn-danger">
              Próba modyfikacji (nie zadziała)
            </button>
          </div>

          <div class="counter">
            Nieudane próby modyfikacji: {{ readonlyCounter }}
          </div>

          <div class="warning-box">
            Parametry krytyczne są zabezpieczone przed modyfikacją
          </div>
        </div>
      </div>

      <div class="code-example">
        <h4>Przykład kodu:</h4>
        <pre>const config = readonly(reactive({
  apiKey: 'secret',
  maxRetries: 3
}))

// Nie zadziała - readonly
config.maxRetries = 5 // Warning w konsoli

// Możemy tylko czytać
console.log(config.maxRetries) // 3</pre>
      </div>
    </div>

    <div class="info-box">
      <h3>Kiedy używać zaawansowanych funkcji?</h3>
      <div class="use-cases">
        <div class="use-case">
          <h4>shallowRef()</h4>
          <p>Duże obiekty, gdzie zmieniasz cały obiekt naraz, nie pojedyncze właściwości</p>
        </div>
        <div class="use-case">
          <h4>shallowReactive()</h4>
          <p>Płaskie struktury danych z wieloma właściwościami na pierwszym poziomie</p>
        </div>
        <div class="use-case">
          <h4>readonly()</h4>
          <p>Konfiguracje, stałe, dane które nie powinny być modyfikowane</p>
        </div>
        <div class="use-case">
          <h4>triggerRef()</h4>
          <p>Manualne wymuszenie aktualizacji po modyfikacji shallowRef</p>
        </div>
      </div>
    </div>
  </div>
</template>

<style scoped>
.advanced-reactivity {
  min-height: 100vh;
  background: #0a0e27;
  color: #e0e0e0;
  padding: 2rem;
  font-family: 'Courier New', monospace;
}

.header {
  text-align: center;
  margin-bottom: 2rem;
  border-bottom: 2px solid #00ff88;
  padding-bottom: 1rem;
}

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

.subtitle {
  color: #00b4d8;
  margin: 0.5rem 0 0 0;
}

.demo-section {
  background: #1a1f3a;
  padding: 1.5rem;
  border-radius: 8px;
  border: 1px solid #00b4d8;
  margin-bottom: 2rem;
}

.demo-section h2 {
  color: #00ff88;
  margin-top: 0;
}

.demo-grid {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(350px, 1fr));
  gap: 1.5rem;
  margin-bottom: 1.5rem;
}

.info-card, .data-card {
  background: #0a0e27;
  padding: 1.5rem;
  border-radius: 6px;
}

.info-card h3, .data-card h3 {
  color: #00b4d8;
  margin-top: 0;
}

.info-card ul {
  list-style: none;
  padding: 0;
}

.info-card li {
  margin: 0.8rem 0;
  padding-left: 1.5rem;
  position: relative;
}

.info-card code {
  background: #1a1f3a;
  padding: 0.2rem 0.5rem;
  border-radius: 3px;
  color: #00ff88;
}

.data-card pre {
  background: #1a1f3a;
  padding: 1rem;
  border-radius: 4px;
  overflow-x: auto;
  font-size: 0.85rem;
  color: #00ff88;
}

.controls {
  display: flex;
  flex-direction: column;
  gap: 0.8rem;
  margin: 1rem 0;
}

.btn {
  padding: 0.8rem 1rem;
  font-size: 0.9rem;
  border: none;
  border-radius: 6px;
  cursor: pointer;
  font-weight: bold;
  transition: all 0.3s ease;
  font-family: 'Courier New', monospace;
  text-align: left;
}

.btn-success {
  background: linear-gradient(135deg, #00ff88, #00dd77);
  color: #0a0e27;
}

.btn-warning {
  background: linear-gradient(135deg, #ffaa00, #ff8800);
  color: #0a0e27;
}

.btn-danger {
  background: linear-gradient(135deg, #ff4444, #cc0000);
  color: white;
}

.btn-info {
  background: linear-gradient(135deg, #00b4d8, #0088cc);
  color: white;
}

.btn:hover {
  transform: scale(1.02);
  box-shadow: 0 0 15px currentColor;
}

.counter {
  background: #1a1f3a;
  padding: 0.8rem;
  border-radius: 4px;
  text-align: center;
  color: #00ff88;
  font-weight: bold;
  margin-top: 1rem;
}

.status-display p {
  margin: 0.5rem 0;
  color: #ccc;
}

.phase-badge {
  background: #00ff88;
  color: #0a0e27;
  padding: 0.3rem 0.8rem;
  border-radius: 4px;
  font-weight: bold;
}

.modules-grid {
  display: grid;
  gap: 1rem;
  margin-top: 1rem;
}

.module-card {
  background: #1a1f3a;
  padding: 1rem;
  border-radius: 4px;
}

.module-name {
  color: #00b4d8;
  font-weight: bold;
  text-transform: uppercase;
}

.module-status {
  color: #00ff88;
  font-size: 0.9rem;
  margin: 0.3rem 0;
}

.progress-bar {
  height: 24px;
  background: #0a0e27;
  border-radius: 4px;
  overflow: hidden;
  margin-top: 0.5rem;
}

.progress-fill {
  height: 100%;
  background: linear-gradient(90deg, #00b4d8, #00ff88);
  display: flex;
  align-items: center;
  justify-content: center;
  color: #0a0e27;
  font-weight: bold;
  transition: width 0.3s ease;
}

.critical-params {
  background: #1a1f3a;
  padding: 1rem;
  border-radius: 4px;
  border-left: 3px solid #ff4444;
}

.param-item {
  display: flex;
  justify-content: space-between;
  padding: 0.5rem 0;
  border-bottom: 1px solid #333;
}

.param-item:last-child {
  border-bottom: none;
}

.param-label {
  color: #888;
}

.param-value {
  color: #00ff88;
  font-weight: bold;
}

.warning-box {
  background: #2a1f1a;
  border: 1px solid #ff8800;
  padding: 1rem;
  border-radius: 4px;
  color: #ffaa00;
  margin-top: 1rem;
  text-align: center;
}

.code-example {
  background: #0a0e27;
  padding: 1rem;
  border-radius: 6px;
  border-left: 3px solid #00ff88;
}

.code-example h4 {
  color: #00b4d8;
  margin-top: 0;
}

.code-example pre {
  color: #00ff88;
  font-size: 0.85rem;
  overflow-x: auto;
  margin: 0;
}

.info-box {
  background: #1a1f3a;
  padding: 1.5rem;
  border-radius: 8px;
  border-left: 4px solid #00ff88;
}

.info-box h3 {
  color: #00ff88;
  margin-top: 0;
}

.use-cases {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
  gap: 1rem;
  margin-top: 1rem;
}

.use-case {
  background: #0a0e27;
  padding: 1rem;
  border-radius: 4px;
}

.use-case h4 {
  color: #00b4d8;
  margin-top: 0;
}

.use-case p {
  color: #ccc;
  margin: 0;
  font-size: 0.9rem;
}
</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. Co zwraca isRef()?

  2. 2. Co robi unref(value)?

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

Zadania praktyczne w grze

  • Edytor kodu

    Użyj isRef() i isReactive() do sprawdzania typów reaktywnych wartości.

  • Klikanie w kolejności

    Ułóż kod sprawdzający typ wartości:

  • Edytor kodu

    Stwórz funkcję uniwersalną, która działa zarówno z ref jak i zwykłą wartością dzięki unref().

  1. PytanieFunkcja isRef()
  2. PytanieFunkcja unref()
  3. Zadanie z kodemPraktyka: isRef i isReactive
  4. PytanieUtility functions reaktywności
  5. PytanieFunkcja toRaw()
  6. Kliknij w kolejnościSprawdzanie typów reaktywności
  7. Zadanie z kodemPraktyka: unref() w funkcji
  8. PytanieNarzędzia debugowania reaktywności

Przydatne artykuły