Kurs Vue.js · Moduł 3: Reaktywność
Debugowanie Reaktywności
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)) // falseRef 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.33Dł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ętrznychJSON.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 VueisReactive(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. Co zwraca isRef()?
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().