Kurs Vue.js · Moduł 3: Reaktywność
Reaktywność w Praktyce - Panel Kontrolny
W tej lekcji5
Połączmy wszystko w praktycznych przykładach systemów NOVA LAB.
Do tej pory każde narzędzie reaktywności oglądałeś osobno. Prawdziwe panele stacji łączą je naraz: formularz konfiguracji musi walidować dane w locie, monitor modułów filtruje listę według wpisanej frazy, a system zaopatrzenia liczy sumy zamówienia. Wszystkie trzy panele poniżej mają ten sam układ warstw. Najpierw dane w ref() lub reactive(), potem wartości wyliczane przez computed(), dalej akcje, czyli funkcje zmieniające stan, a na końcu szablon z reaktywnymi wiązaniami.
Panel Konfiguracji Reaktora z Walidacją
Szablon formularza używa v-model, czyli wiązania dwukierunkowego pola z danymi, które szczegółowo poznasz w module 5. Modyfikator .number zamienia wpisany tekst na liczbę, a @submit.prevent i :disabled znasz z modułu 2:
<template>
<form @submit.prevent="submitConfig" class="reactor-config" style="background: #0a0e27; color: #00ff88;">
<div>
<label>Nazwa modułu:</label>
<input v-model="config.name" style="background: #1a1e37; color: #00ff88;" />
<span v-if="errors.name" style="color: #ff4444;">{{ errors.name }}</span>
</div>
<div>
<label>Temperatura maksymalna (K):</label>
<input v-model.number="config.maxTemp" type="number" style="background: #1a1e37; color: #00ff88;" />
<span v-if="errors.maxTemp" style="color: #ff4444;">{{ errors.maxTemp }}</span>
</div>
<div>
<label>Status:</label>
<input v-model="config.status" style="background: #1a1e37; color: #00ff88;" />
</div>
<button :disabled="!isValid" style="background: #00b4d8; color: #0a0e27;">Zapisz konfigurację</button>
</form>
</template>Komunikaty błędów pojawiają się przez v-if tylko wtedy, gdy jest co pokazać, a przycisk zapisu blokuje się, dopóki formularz nie jest poprawny. Dane formularza to spójna grupa pól, więc trzymamy je w reactive():
<script setup>
import { reactive, computed } from 'vue'
const config = reactive({
name: '',
maxTemp: null,
status: ''
})Walidacja to wartość wyliczana z tych pól. W pierwszej wersji tego panelu computed sam zapisywał komunikaty do osobnego obiektu errors. Dokumentacja Vue zabrania jednak efektów ubocznych w computed: getter ma tylko liczyć i zwracać wynik. Dlatego same błędy są tutaj computed:
// Walidacja jako wartość wyliczana - bez efektów ubocznych
const errors = computed(() => ({
// Walidacja nazwy
name: config.name.length < 3 ? 'Nazwa musi mieć min. 3 znaki' : '',
// Walidacja temperatury
maxTemp: config.maxTemp && (config.maxTemp < 1000 || config.maxTemp > 10000)
? 'Temperatura musi być między 1000 a 10000 K'
: ''
}))
const isValid = computed(() => !errors.value.name && !errors.value.maxTemp)Szablon nie wymagał żadnej zmiany: errors to ref na najwyższym poziomie, więc errors.name działa w nim bez .value. Wpisanie trzeciego znaku nazwy przelicza oba computed i odblokowuje przycisk. Akcja wysyłająca konfigurację czyta już tylko gotowy wynik:
function submitConfig() {
if (isValid.value) {
console.log('Wysyłanie konfiguracji do NOVA LAB:', config)
}
}
</script>System Monitoringu Modułów
Monitor łączy pole wyszukiwania i listę rozwijaną z przefiltrowaną listą modułów. v-model działa także na <select>:
<template>
<div class="module-monitor" style="background: #0a0e27; color: #00ff88;">
<input v-model="searchQuery" placeholder="Szukaj modułu..." style="background: #1a1e37; color: #00ff88;" />
<select v-model="filterStatus" style="background: #1a1e37; color: #00ff88;">
<option value="">Wszystkie statusy</option>
<option value="ACTIVE">Aktywne</option>
<option value="STANDBY">Gotowość</option>
</select>
<ul>
<li v-for="module in filteredModules" :key="module.id" style="border-bottom: 1px solid #00b4d8;">
{{ module.name }} - {{ module.status }}
</li>
</ul>
<p>Znaleziono: {{ filteredModules.length }} modułów</p>
</div>
</template>Szablon nie filtruje niczego sam - dostaje gotową listę filteredModules. Stan to dwa proste refy i tablica modułów:
<script setup>
import { ref, computed } from 'vue'
const searchQuery = ref('')
const filterStatus = ref('')
const modules = ref([
{ id: 1, name: 'Oxygen Generator Alpha', status: 'ACTIVE' },
{ id: 2, name: 'Plasma Core Beta', status: 'STANDBY' },
{ id: 3, name: 'Water Recycler Gamma', status: 'ACTIVE' },
{ id: 4, name: 'Power Distributor Delta', status: 'STANDBY' }
])Filtr łączy oba warunki. Zapis !filterStatus.value || znaczy: gdy nie wybrano statusu, przepuść każdy moduł:
const filteredModules = computed(() => {
return modules.value.filter(module => {
const matchesSearch = module.name
.toLowerCase()
.includes(searchQuery.value.toLowerCase())
const matchesStatus = !filterStatus.value ||
module.status === filterStatus.value
return matchesSearch && matchesStatus
})
})
</script>Oryginalna tablica modules pozostaje nietknięta, a lista na ekranie odświeża się przy każdym wpisanym znaku.
System Zaopatrzenia Misji
Zamówienie zaopatrzenia pokazuje liczbę sztuk, pozycje z przyciskiem usuwania i sumę w kredytach:
<template>
<div class="supply-cart" style="background: #0a0e27; color: #00ff88;">
<h2>Zamówienie ({{ supplies.itemCount }} pozycji)</h2>
<div v-for="item in supplies.items" :key="item.id" style="border-bottom: 1px solid #00b4d8;">
{{ item.name }} - {{ item.quantity }} x {{ item.price }} CR
<button @click="removeItem(item.id)" style="background: #ff4444; color: #fff;">Usuń</button>
</div>
<p><strong>Suma: {{ supplies.total }} CR (Kredyty)</strong></p>
</div>
</template>Tutaj wartości wyliczane zapisano inaczej niż w poprzednich panelach: jako gettery wewnątrz samego obiektu reaktywnego. Getter to właściwość JavaScriptu, której wartość przy każdym odczycie liczy funkcja oznaczona słowem get:
<script setup>
import { reactive } from 'vue'
const supplies = reactive({
items: [
{ id: 1, name: 'Oxygen Canister', quantity: 10, price: 50 },
{ id: 2, name: 'Plasma Cell', quantity: 5, price: 200 }
],
// Computed jako właściwość
get itemCount() {
return this.items.reduce((sum, item) => sum + item.quantity, 0)
},
get total() {
return this.items.reduce((sum, item) =>
sum + item.quantity * item.price, 0)
}
})Na starcie itemCount wynosi 15, a total 1500 CR. Getter liczy wynik przy każdym odczycie i w przeciwieństwie do computed() go nie zapamiętuje, co przy krótkiej liście nie ma znaczenia. Akcja usuwania zmienia tablicę w miejscu:
function removeItem(id) {
const index = supplies.items.findIndex(item => item.id === id)
if (index > -1) {
supplies.items.splice(index, 1)
}
}
</script>Po usunięciu ogniw plazmowych suma spada do 500 CR, bo splice to metoda, którą Vue wykrywa.
readonly() - Podgląd bez Prawa Zapisu
Monitor w mesie ma pokazywać stan reaktora, ale nie może go zmieniać. readonly() zwraca głębokie Proxy tylko do odczytu:
import { reactive, readonly } from 'vue'
const reactorState = reactive({ temperature: 2500 })
const reactorView = readonly(reactorState)
reactorView.temperature = 9999 // ostrzeżenie w konsoli, zmiana odrzucona
reactorState.temperature = 2600 // zmiana przez oryginał działa
console.log(reactorView.temperature) // 2600Próba zapisu kończy się w trybie deweloperskim ostrzeżeniem Vue, a wartość zostaje bez zmian. Widok tylko do odczytu nie jest kopią: pokazuje każdą zmianę oryginału. Wzorzec jest prosty - modyfikowalny stan trzymasz u siebie, na zewnątrz udostępniasz wersję readonly, a zmiany robisz wyłącznie przez własne funkcje.
Dobór Narzędzi
Dokumentacja Vue zaleca ref() jako podstawowe narzędzie. reactive() sprawdza się przy spójnych grupach pól, shallowRef() z triggerRef() przy ogromnych listach, markRaw() przy instancjach z bibliotek zewnętrznych, a readonly() przy udostępnianiu stanu. Pod spodem Vue 3 przechwytuje dostęp do obiektów natywnym Proxy, a do refów getterami i setterami. Trzymaj się podziału na dane, wartości wyliczane, akcje i szablon a każdy panel będzie czytelny. W projekcie modułu zbudujesz z tych warstw pełny system monitorowania reaktora.
Zapamiętaj: dobry panel stacji ma jedno źródło prawdy, wartości wyliczane zamiast ręcznych kopii i akcje, które jako jedyne dotykają stanu.
Kod do tej lekcji: App.vue
<script setup>
import { ref, reactive, markRaw, isReactive, toRaw } from 'vue'
// markRaw() - Kontrola reaktora plazmowego
// Zaawansowana kontrola reaktywności w NOVA LAB
// Symulator dużego obiektu (np. biblioteka 3D)
class HeavySimulationEngine {
constructor(name) {
this.name = name
this.iterations = 0
this.data = new Array(1000).fill(0).map((_, i) => ({
id: i,
value: Math.random() * 100
}))
}
simulate() {
this.iterations++
// Ciężkie obliczenia
return this.data.reduce((sum, item) => sum + item.value, 0)
}
reset() {
this.iterations = 0
}
}
// Reactor z normalnym obiektem (reaktywny)
const reactiveReactor = reactive({
id: 'REACTOR-A',
status: 'ONLINE',
power: 100,
engine: new HeavySimulationEngine('Reactive Engine'),
lastUpdate: new Date().toISOString()
})
// Reactor z markRaw (silnik nie reaktywny)
const optimizedReactor = reactive({
id: 'REACTOR-B',
status: 'ONLINE',
power: 100,
engine: markRaw(new HeavySimulationEngine('Optimized Engine')),
lastUpdate: new Date().toISOString()
})
// Sprawdzenie reaktywności
const reactiveEngineIsReactive = isReactive(reactiveReactor.engine)
const optimizedEngineIsReactive = isReactive(optimizedReactor.engine)
// Counters dla demonstracji wydajności
const reactiveSimulationCount = ref(0)
const optimizedSimulationCount = ref(0)
function runReactiveSimulation() {
const start = performance.now()
// Modyfikacja reaktywnego silnika
reactiveReactor.engine.simulate()
reactiveReactor.lastUpdate = new Date().toISOString()
reactiveSimulationCount.value++
const end = performance.now()
console.log(`Reactive simulation: ${(end - start).toFixed(2)}ms`)
}
function runOptimizedSimulation() {
const start = performance.now()
// Modyfikacja markRaw silnika
optimizedReactor.engine.simulate()
optimizedReactor.lastUpdate = new Date().toISOString()
optimizedSimulationCount.value++
const end = performance.now()
console.log(`Optimized simulation: ${(end - start).toFixed(2)}ms`)
}
// Przykład praktyczny - mapa z wieloma obiektami
const sensorNetwork = reactive({
location: 'Mars Base Alpha',
activeSensors: 0,
sensors: markRaw(new Map([
['TEMP-001', { type: 'temperature', value: 22 }],
['PRES-001', { type: 'pressure', value: 101 }],
['OXY-001', { type: 'oxygen', value: 21 }]
]))
})
function addSensor() {
const id = `SENS-${Date.now()}`
sensorNetwork.sensors.set(id, {
type: 'generic',
value: Math.random() * 100
})
// Aktualizujemy reaktywny licznik
sensorNetwork.activeSensors = sensorNetwork.sensors.size
}
function removeSensor() {
const keys = Array.from(sensorNetwork.sensors.keys())
if (keys.length > 0) {
sensorNetwork.sensors.delete(keys[keys.length - 1])
sensorNetwork.activeSensors = sensorNetwork.sensors.size
}
}
// toRaw() - dostęp do oryginalnego obiektu
function getRawReactor() {
const raw = toRaw(reactiveReactor)
console.log('Raw reactor (non-reactive):', raw)
console.log('Is reactive?', isReactive(raw)) // false
}
// Przykład z integracją zewnętrznej biblioteki
const chartConfig = reactive({
title: 'Reactor Power Output',
// Duża biblioteka wykresów - nie potrzebujemy jej reaktywnej
chartInstance: markRaw({
render() {
return 'Chart rendered'
},
update(data) {
console.log('Chart updated with:', data)
},
destroy() {
console.log('Chart destroyed')
}
})
})
function updateChart() {
chartConfig.chartInstance.update({
power: reactiveReactor.power,
timestamp: new Date()
})
}
</script>
<template>
<div class="mark-raw-demo">
<div class="header">
<h1>KONTROLA REAKTORA - NOVA LAB</h1>
<p class="subtitle">markRaw() i toRaw() - Zaawansowana kontrola reaktywności</p>
</div>
<!-- Porównanie wydajności -->
<div class="comparison-section">
<h2>Porównanie wydajności: Reaktywny vs markRaw</h2>
<div class="reactors-grid">
<!-- Reaktor A - Reaktywny -->
<div class="reactor-card">
<div class="reactor-header">
<h3>{{ reactiveReactor.id }}</h3>
<span class="badge badge-reactive">REAKTYWNY</span>
</div>
<div class="reactor-stats">
<div class="stat">
<div class="label">Status</div>
<div class="value">{{ reactiveReactor.status }}</div>
</div>
<div class="stat">
<div class="label">Moc</div>
<div class="value">{{ reactiveReactor.power }}%</div>
</div>
<div class="stat">
<div class="label">Iteracje silnika</div>
<div class="value">{{ reactiveReactor.engine.iterations }}</div>
</div>
<div class="stat">
<div class="label">Silnik reaktywny?</div>
<div class="value">{{ reactiveEngineIsReactive ? 'TAK' : 'NIE' }}</div>
</div>
</div>
<div class="simulation-info">
<p>Symulacje uruchomione: <strong>{{ reactiveSimulationCount }}</strong></p>
<p class="warning">Każda zmiana w silniku wywołuje reaktywność!</p>
</div>
<button @click="runReactiveSimulation" class="btn btn-primary">
▶Uruchom symulację
</button>
<div class="code-box">
<pre>// Normalny obiekt - reaktywny
const reactor = reactive({
engine: new Engine()
})
// engine i wszystkie jego właściwości
// są reaktywne Wolniejsze!</pre>
</div>
</div>
<!-- Reaktor B - Zoptymalizowany -->
<div class="reactor-card">
<div class="reactor-header">
<h3>{{ optimizedReactor.id }}</h3>
<span class="badge badge-optimized">ZOPTYMALIZOWANY</span>
</div>
<div class="reactor-stats">
<div class="stat">
<div class="label">Status</div>
<div class="value">{{ optimizedReactor.status }}</div>
</div>
<div class="stat">
<div class="label">Moc</div>
<div class="value">{{ optimizedReactor.power }}%</div>
</div>
<div class="stat">
<div class="label">Iteracje silnika</div>
<div class="value">{{ optimizedReactor.engine.iterations }}</div>
</div>
<div class="stat">
<div class="label">Silnik reaktywny?</div>
<div class="value">{{ optimizedEngineIsReactive ? 'TAK' : 'NIE' }}</div>
</div>
</div>
<div class="simulation-info">
<p>Symulacje uruchomione: <strong>{{ optimizedSimulationCount }}</strong></p>
<p class="success">Silnik nie jest reaktywny - wydajniejsze!</p>
</div>
<button @click="runOptimizedSimulation" class="btn btn-success">
Uruchom symulację (szybsza)
</button>
<div class="code-box">
<pre>// markRaw - nie reaktywny
const reactor = reactive({
engine: markRaw(new Engine())
})
// engine NIE jest reaktywny
// Szybsze!</pre>
</div>
</div>
</div>
</div>
<!-- Sieć sensorów -->
<div class="sensors-section">
<h2>Sieć sensorów (praktyczny przykład markRaw)</h2>
<div class="sensors-card">
<div class="sensors-header">
<h3>{{ sensorNetwork.location }}</h3>
<div class="sensor-count">
Aktywne sensory: <strong>{{ sensorNetwork.activeSensors }}</strong>
</div>
</div>
<div class="sensors-grid">
<div
v-for="[id, sensor] in sensorNetwork.sensors"
:key="id"
class="sensor-item"
>
<div class="sensor-id">{{ id }}</div>
<div class="sensor-type">{{ sensor.type }}</div>
<div class="sensor-value">{{ sensor.value.toFixed(2) }}</div>
</div>
</div>
<div class="controls">
<button @click="addSensor" class="btn btn-success">
Dodaj sensor
</button>
<button @click="removeSensor" class="btn btn-danger">
Usuń sensor
</button>
</div>
<div class="info">
<p>Mapa sensorów używa <code>markRaw()</code></p>
<p>Tylko licznik <code>activeSensors</code> jest reaktywny</p>
</div>
<div class="code-box">
<pre>const network = reactive({
activeSensors: 0,
// Map nie musi być reaktywny
sensors: markRaw(new Map())
})
// Aktualizuj tylko reaktywny licznik
network.activeSensors = network.sensors.size</pre>
</div>
</div>
</div>
<!-- Integracja bibliotek -->
<div class="library-section">
<h2>Integracja z zewnętrznymi bibliotekami</h2>
<div class="library-card">
<h3>{{ chartConfig.title }}</h3>
<div class="chart-placeholder">
<div class="chart-visual">
Wykres mocy reaktora
</div>
<p>Instance wykresu: {{ chartConfig.chartInstance.render() }}</p>
</div>
<button @click="updateChart" class="btn btn-info">
Aktualizuj wykres
</button>
<div class="code-box">
<pre>import Chart from 'chart-library'
const config = reactive({
title: 'My Chart',
// Duża biblioteka - nie potrzebujemy reaktywności
chartInstance: markRaw(new Chart())
})
// Ręcznie aktualizuj gdy potrzeba
config.chartInstance.update(newData)</pre>
</div>
</div>
</div>
<!-- toRaw() demo -->
<div class="toraw-section">
<h2>toRaw() - Dostęp do oryginalnego obiektu</h2>
<div class="toraw-card">
<p>Czasami potrzebujesz dostępu do oryginalnego, nie-reaktywnego obiektu</p>
<button @click="getRawReactor" class="btn btn-warning">
Pobierz RAW reactor (sprawdź konsolę)
</button>
<div class="code-box">
<pre>const reactive = reactive({ value: 1 })
// Pobierz oryginalny obiekt
const raw = toRaw(reactive)
// Zmiany w raw NIE wywołają reaktywności
raw.value = 2
console.log(isReactive(raw)) // false</pre>
</div>
<div class="use-cases">
<h4>Kiedy używać toRaw()?</h4>
<ul>
<li>Przekazywanie do API które nie potrzebuje reaktywności</li>
<li>Operacje na surowych danych bez wywołania reaktywności</li>
<li>Debugowanie - sprawdzanie oryginalnych wartości</li>
</ul>
</div>
</div>
</div>
<!-- Info box -->
<div class="info-box">
<h3>Kiedy używać markRaw()?</h3>
<div class="use-cases-grid">
<div class="use-case">
<h4>Duże obiekty danych</h4>
<p>Gigantyczne struktury danych, które nie muszą być reaktywne</p>
</div>
<div class="use-case">
<h4>Zewnętrzne biblioteki</h4>
<p>Instancje Chart.js, Three.js, D3.js - nie potrzebują reaktywności</p>
</div>
<div class="use-case">
<h4>Map, Set, WeakMap</h4>
<p>Kolekcje które zmieniasz często, ale nie potrzebujesz śledzić każdej zmiany</p>
</div>
<div class="use-case">
<h4>Optymalizacja wydajności</h4>
<p>Gdy reaktywność spowalnia aplikację niepotrzebnie</p>
</div>
</div>
<div class="warning-box">
<h4>Uwaga!</h4>
<p><code>markRaw()</code> jest nieodwracalny - obiekt nigdy nie stanie się reaktywny!</p>
<p>Używaj tylko gdy jesteś pewny, że reaktywność nie jest potrzebna.</p>
</div>
</div>
</div>
</template>
<style scoped>
.mark-raw-demo {
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;
}
.comparison-section,
.sensors-section,
.library-section,
.toraw-section {
background: #1a1f3a;
padding: 1.5rem;
border-radius: 8px;
border: 1px solid #00b4d8;
margin-bottom: 2rem;
}
h2 {
color: #00ff88;
margin-top: 0;
}
.reactors-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(400px, 1fr));
gap: 1.5rem;
}
.reactor-card,
.sensors-card,
.library-card,
.toraw-card {
background: #0a0e27;
padding: 1.5rem;
border-radius: 6px;
}
.reactor-header,
.sensors-header {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 1.5rem;
padding-bottom: 1rem;
border-bottom: 1px solid #333;
}
.reactor-header h3,
.sensors-header h3 {
color: #00b4d8;
margin: 0;
}
.badge {
padding: 0.3rem 0.8rem;
border-radius: 20px;
font-size: 0.8rem;
font-weight: bold;
}
.badge-reactive {
background: #ff8800;
color: #0a0e27;
}
.badge-optimized {
background: #00ff88;
color: #0a0e27;
}
.reactor-stats {
display: grid;
grid-template-columns: repeat(2, 1fr);
gap: 1rem;
margin-bottom: 1.5rem;
}
.stat {
background: #1a1f3a;
padding: 1rem;
border-radius: 4px;
}
.stat .label {
font-size: 0.85rem;
color: #888;
margin-bottom: 0.3rem;
}
.stat .value {
font-size: 1.2rem;
color: #00ff88;
font-weight: bold;
}
.simulation-info {
background: #1a1f3a;
padding: 1rem;
border-radius: 4px;
margin-bottom: 1rem;
}
.simulation-info p {
margin: 0.5rem 0;
}
.simulation-info strong {
color: #00ff88;
}
.warning {
color: #ff8800;
}
.success {
color: #00ff88;
}
.btn {
width: 100%;
padding: 1rem;
font-size: 1rem;
border: none;
border-radius: 6px;
cursor: pointer;
font-weight: bold;
transition: all 0.3s ease;
font-family: 'Courier New', monospace;
margin-bottom: 1rem;
}
.btn-primary {
background: linear-gradient(135deg, #00b4d8, #0088cc);
color: white;
}
.btn-success {
background: linear-gradient(135deg, #00ff88, #00dd77);
color: #0a0e27;
}
.btn-danger {
background: linear-gradient(135deg, #ff4444, #cc0000);
color: white;
}
.btn-info {
background: linear-gradient(135deg, #00b4d8, #00ff88);
color: #0a0e27;
}
.btn-warning {
background: linear-gradient(135deg, #ffaa00, #ff8800);
color: #0a0e27;
}
.btn:hover {
transform: scale(1.02);
box-shadow: 0 0 20px currentColor;
}
.code-box {
background: #1a1f3a;
padding: 1rem;
border-radius: 4px;
border-left: 3px solid #00ff88;
}
.code-box pre {
margin: 0;
color: #00ff88;
font-size: 0.85rem;
overflow-x: auto;
}
.sensor-count {
color: #00ff88;
font-weight: bold;
}
.sensors-grid {
display: grid;
grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
gap: 1rem;
margin: 1.5rem 0;
}
.sensor-item {
background: #1a1f3a;
padding: 1rem;
border-radius: 4px;
border-left: 3px solid #00b4d8;
}
.sensor-id {
color: #00b4d8;
font-weight: bold;
font-size: 0.9rem;
}
.sensor-type {
color: #888;
font-size: 0.85rem;
margin: 0.3rem 0;
text-transform: uppercase;
}
.sensor-value {
color: #00ff88;
font-size: 1.2rem;
font-weight: bold;
}
.controls {
display: flex;
gap: 1rem;
}
.controls .btn {
flex: 1;
}
.info {
background: #1a1f3a;
padding: 1rem;
border-radius: 4px;
margin-top: 1rem;
}
.info p {
margin: 0.5rem 0;
color: #ccc;
}
.info code {
background: #0a0e27;
padding: 0.2rem 0.5rem;
border-radius: 3px;
color: #00ff88;
}
.chart-placeholder {
background: #1a1f3a;
padding: 2rem;
border-radius: 4px;
text-align: center;
margin: 1rem 0;
}
.chart-visual {
font-size: 3rem;
margin-bottom: 1rem;
}
.use-cases {
background: #1a1f3a;
padding: 1rem;
border-radius: 4px;
margin-top: 1rem;
}
.use-cases h4 {
color: #00b4d8;
margin-top: 0;
}
.use-cases ul {
color: #ccc;
padding-left: 1.5rem;
}
.use-cases li {
margin: 0.5rem 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-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
gap: 1rem;
margin: 1rem 0;
}
.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;
}
.warning-box {
background: #2a1f1a;
border: 2px solid #ff8800;
padding: 1rem;
border-radius: 4px;
margin-top: 1rem;
}
.warning-box h4 {
color: #ffaa00;
margin-top: 0;
}
.warning-box p {
color: #ccc;
margin: 0.5rem 0;
}
.warning-box code {
background: #0a0e27;
padding: 0.2rem 0.5rem;
border-radius: 3px;
color: #00ff88;
}
</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. Która praktyka jest zalecana w Vue 3?
2. Na czym opiera się system reaktywności Vue 3?
To 2 z 11 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Użyj readonly() do zabezpieczenia stanu przed mutacją.
- Układanie w pionie
Ułóż wzorzec użycia readonly do ochrony stanu:
- Klikanie w kolejności
Ułóż kod markRaw() z biblioteką zewnętrzną:
- Edytor kodu
Użyj markRaw() żeby zapobiec reaktywności dla dużych lub zewnętrznych obiektów.
- Układanie w pionie
Ułóż kroki optymalizacji z shallowRef i triggerRef:
- Klikanie w kolejności
Ułóż import najbardziej potrzebnych API reaktywności:
- Układanie w pionie
Ułóż koncepcje reaktywności od podstawowych do zaawansowanych:
- Układanie w pionie
Ułóż składnię tworzenia shallowRef:
- Układanie w pionie
Ułóż architekturę stanu komponentu od danych do widoku:
- Klikanie w kolejności
Ułóż kod reaktywnego formularza:
Zadania po tej lekcji
- PytanieZalecane praktyki reaktywności
- PytanieProxy API w Vue 3
- Zadanie z kodemPraktyka: readonly()
- PytanieFunkcja readonly()
- Ułóż w kolejnościWzorzec readonly w komponencie
- PytanieFunkcja markRaw()
- Kliknij w kolejnościUżycie markRaw z biblioteką
- Zadanie z kodemPraktyka: markRaw() zewnętrzne
- PytanieZaawansowane API reaktywności
- PytanietriggerRef() funkcja
- PytanieWydajność z shallowRef
- Ułóż w kolejnościOptymalizacja z triggerRef
- PytanieWybór narzędzia reaktywności
- PytanieMutacja reactive - bezpośrednia
- Kliknij w kolejnościImport reaktywnych API
- Ułóż w kolejnościOd prostego do zaawansowanego
- PytanieDestructuring a toRefs
- Ułóż w kolejnościSkładnia shallowRef
- Ułóż w kolejnościArchitektura stanu w komponencie
- Kliknij w kolejnościTworzenie formularza reaktywnego
- PytanieisReactive() funkcja