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

Reaktywność w Praktyce - Panel Kontrolny

6 min czytania ·
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) // 2600

Pró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. 1. Która praktyka jest zalecana w Vue 3?

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

  1. PytanieZalecane praktyki reaktywności
  2. PytanieProxy API w Vue 3
  3. Zadanie z kodemPraktyka: readonly()
  4. PytanieFunkcja readonly()
  5. Ułóż w kolejnościWzorzec readonly w komponencie
  6. PytanieFunkcja markRaw()
  7. Kliknij w kolejnościUżycie markRaw z biblioteką
  8. Zadanie z kodemPraktyka: markRaw() zewnętrzne
  9. PytanieZaawansowane API reaktywności
  10. PytanietriggerRef() funkcja
  11. PytanieWydajność z shallowRef
  12. Ułóż w kolejnościOptymalizacja z triggerRef
  13. PytanieWybór narzędzia reaktywności
  14. PytanieMutacja reactive - bezpośrednia
  15. Kliknij w kolejnościImport reaktywnych API
  16. Ułóż w kolejnościOd prostego do zaawansowanego
  17. PytanieDestructuring a toRefs
  18. Ułóż w kolejnościSkładnia shallowRef
  19. Ułóż w kolejnościArchitektura stanu w komponencie
  20. Kliknij w kolejnościTworzenie formularza reaktywnego
  21. PytanieisReactive() funkcja

Przydatne artykuły