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

reactive() - Reaktywne Systemy

4 min czytania ·
W tej lekcji4

Gdy pracujesz z kompleksowymi obiektami systemów, reactive() jest często wygodniejszy niż ref() - to jak kompletny panel kontrolny reaktora zamiast pojedynczych wskaźników.

Reaktor ma nazwę, status, temperaturę i dwa odczyty: moc i promieniowanie. Pięć osobnych refów oznacza pięć deklaracji i .value w każdej linii skryptu, choć wszystkie te dane opisują jedno urządzenie. reactive() pozwala zamknąć je w jednym obiekcie, który cały jest reaktywny.

Podstawy reactive()

reactive() przyjmuje obiekt i zwraca jego Proxy - wbudowany w JavaScript mechanizm, który przechwytuje każdy odczyt i zapis właściwości. Dzięki temu nie potrzebujesz .value, a zagnieżdżone obiekty też stają się reaktywne:

import { reactive } from 'vue'

const reactor = reactive({
  name: 'Plasma Core Alpha',
  status: 'ACTIVE',
  temperature: 2500,
  readings: {
    power: 850,
    radiation: 12
  }
})

// Dostęp bez .value!
console.log(reactor.name) // 'Plasma Core Alpha'
reactor.temperature = 2600

// Zagnieżdżone obiekty też są reaktywne
reactor.readings.power = 900 // To też wywoła aktualizację panelu

Proxy działa jak dyspozytor między Tobą a danymi: każdą zmianę zgłasza systemowi, który odświeża zależne widoki. Zauważ, co się nie zmieniło - reaktywny jest tylko obiekt zwrócony przez reactive(), a nie oryginał, który do niego podałeś:

const raw = { status: 'STANDBY' }
const panel = reactive(raw)

console.log(panel === raw)           // false
console.log(reactive(raw) === panel) // true

Proxy to inny obiekt niż oryginał, a zmiany zapisane wprost w raw nie odświeżą widoku. Ponowne wywołanie reactive() dla tego samego obiektu zwraca to samo Proxy, więc zawsze pracuj na wersji reaktywnej.

reactive() vs ref()

Oba narzędzia dają reaktywność, ale różnią się w codziennym użyciu:

Cecharef()reactive()
Dla prymitywówTakNie
Dla obiektówTak (.value)Tak (bezpośrednio)
DestructuringBezpieczne (przekazujesz cały kontener)Traci reaktywność
ReassignTak (.value = newObj)Nie (tylko właściwości)

Ref możesz przekazać do funkcji albo wyjąć z obiektu i nadal będzie reaktywny, bo krąży cały kontener. Z reactive() wyciągasz natomiast gołe wartości. Dokumentacja Vue zaleca ref() jako podstawowe API właśnie z powodu tych ograniczeń.

Praktyczny Przykład

Oto panel reaktora zbudowany na jednym obiekcie. Szablon czyta także zagnieżdżone odczyty:

<template>
  <div class="reactor-panel" style="background: #0a0e27; color: #00ff88; border: 1px solid #00b4d8;">
    <h2>{{ reactor.name }}</h2>
    <p>Status: {{ reactor.status }}</p>
    <p>Temperatura: {{ reactor.temperature }} K</p>
    <p>Odczyty: {{ reactor.readings.power }} MW | {{ reactor.readings.radiation }} Sv/h</p>

    <button @click="updateTemperature">Zwiększ temperaturę</button>
  </div>
</template>

W szablonie nie ma ani jednego .value, bo reactor jest obiektem reaktywnym, a nie refem. Skrypt tworzy ten obiekt i funkcję, która zmienia jedną właściwość:

<script setup>
import { reactive } from 'vue'

const reactor = reactive({
  name: 'Plasma Core Alpha',
  status: 'ACTIVE',
  temperature: 2500,
  readings: {
    power: 850,
    radiation: 12
  }
})

function updateTemperature() {
  reactor.temperature += 100 // Bezpośrednia modyfikacja
}
</script>

Każde kliknięcie podnosi temperaturę o 100 K, a panel pokazuje nową wartość. Zmienna reactor przez cały czas wskazuje na to samo Proxy - zmieniają się tylko jego właściwości.

Ograniczenia reactive()

Pierwsze ograniczenie: reactive() działa tylko z obiektami, tablicami oraz kolekcjami Map i Set. Dla liczby Vue wypisze ostrzeżenie i zwróci ją bez zmian. Drugie dotyczy podmiany całego obiektu:

import { reactive } from 'vue'

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

// ŹLE - zastąpienie całego obiektu
reactor = { name: 'Plasma Core Beta' } // To nie zadziała!

// DOBRZE - modyfikacja właściwości
reactor.name = 'Plasma Core Beta'

Przy const sam JavaScript rzuci TypeError (przypisanie do stałej). Przy let zmienna wskazałaby nowy, zwykły obiekt, a szablon zostałby przy starym Proxy, więc połączenie by się zerwało. Dlatego zmieniasz właściwości, a nie cały obiekt. Gdy nowe dane przychodzą w całości, na przykład z telemetrii, przepisz je przez Object.assign(reactor, newData) - to nadal zmiana właściwości tego samego Proxy. Trzecie ograniczenie to destrukturyzacja:

// ŹLE - destructuring traci reaktywność
const { name } = reactor // name nie jest reaktywny!

// DOBRZE - użyj toRefs
import { toRefs } from 'vue'
const { name } = toRefs(reactor) // name.value jest reaktywny

Destrukturyzacja kopiuje bieżącą wartość, a toRefs tworzy refy powiązane z właściwościami - dokładnie omówimy go w lekcji o toRef i toRefs. Moja praktyka w NOVA LAB: domyślnie ref(), a reactive() dla spójnej grupy pól, na przykład formularza konfiguracji. W następnej lekcji sprawdzisz, jak głęboko sięga ta reaktywność i kiedy warto ją spłycić.

Zapamiętaj: reactive() to panel kontrolny za szybą Proxy - kręcisz pokrętłami, ale nigdy nie wymieniasz całego panelu.

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

// Porównanie ref() vs reactive()
// Zarządzanie zbiornikami tlenu na stacji NOVA LAB

// ref() - pojedyncze wartości
const mainTankLevel = ref(100)
const backupTankLevel = ref(75)
const oxygenFlow = ref(2.5)

// reactive() - kompleksowy obiekt
const oxygenSystem = reactive({
  mainTank: {
    level: 100,
    capacity: 1000,
    pressure: 150,
    status: 'OPTIMAL'
  },
  backupTank: {
    level: 75,
    capacity: 500,
    pressure: 120,
    status: 'STANDBY'
  },
  flow: {
    rate: 2.5,
    direction: 'OUT',
    consumers: 12
  }
})

// Symulacja zużycia tlenu
let simulationInterval = null

function startSimulation() {
  if (simulationInterval) return

  simulationInterval = setInterval(() => {
    // Używanie ref - musimy użyć .value
    if (mainTankLevel.value > 0) {
      mainTankLevel.value -= 0.5
    }

    // Używanie reactive - bezpośredni dostęp do właściwości
    if (oxygenSystem.mainTank.level > 0) {
      oxygenSystem.mainTank.level -= 0.5

      if (oxygenSystem.mainTank.level < 30) {
        oxygenSystem.mainTank.status = 'WARNING'
      }
      if (oxygenSystem.mainTank.level < 10) {
        oxygenSystem.mainTank.status = 'CRITICAL'
      }
    }
  }, 100)
}

function stopSimulation() {
  if (simulationInterval) {
    clearInterval(simulationInterval)
    simulationInterval = null
  }
}

function refill() {
  // ref - używamy .value
  mainTankLevel.value = 100
  backupTankLevel.value = 75

  // reactive - bezpośredni dostęp
  oxygenSystem.mainTank.level = 100
  oxygenSystem.mainTank.status = 'OPTIMAL'
  oxygenSystem.backupTank.level = 75
}

// Przykład: nie możemy zastąpić całego obiektu reactive
function wrongWayToUpdate() {
  // TO NIE ZADZIAŁA - straci reaktywność
  // oxygenSystem = { ...newData }

  // PRAWIDŁOWY SPOSÓB - aktualizuj właściwości
  oxygenSystem.mainTank.level = 100
  oxygenSystem.mainTank.status = 'OPTIMAL'
}
</script>

<template>
  <div class="oxygen-control">
    <div class="header">
      <h1>SYSTEM TLENOWY - NOVA LAB</h1>
      <p class="subtitle">ref() vs reactive() - Porównanie</p>
    </div>

    <div class="comparison-grid">
      <!-- Sekcja ref() -->
      <div class="section">
        <h2 class="section-title">UŻYWAJĄC ref()</h2>
        <div class="card">
          <div class="tank-visual">
            <div class="tank-fill" :style="{ height: mainTankLevel + '%' }">
              <span class="tank-label">{{ mainTankLevel.toFixed(1) }}%</span>
            </div>
          </div>
          <div class="tank-info">
            <p><strong>Zbiornik główny:</strong> {{ mainTankLevel.toFixed(1) }}%</p>
            <p><strong>Zbiornik zapasowy:</strong> {{ backupTankLevel.toFixed(1) }}%</p>
            <p><strong>Przepływ:</strong> {{ oxygenFlow }} L/min</p>
          </div>
          <div class="code-example">
            <pre>const level = ref(100)
// Dostęp: level.value
level.value = 50</pre>
          </div>
        </div>
      </div>

      <!-- Sekcja reactive() -->
      <div class="section">
        <h2 class="section-title">UŻYWAJĄC reactive()</h2>
        <div class="card">
          <div class="tank-visual">
            <div
              class="tank-fill"
              :style="{ height: oxygenSystem.mainTank.level + '%' }"
              :class="oxygenSystem.mainTank.status.toLowerCase()"
            >
              <span class="tank-label">{{ oxygenSystem.mainTank.level.toFixed(1) }}%</span>
            </div>
          </div>
          <div class="tank-info">
            <p>
              <strong>Status:</strong>
              <span :class="'status-' + oxygenSystem.mainTank.status.toLowerCase()">
                {{ oxygenSystem.mainTank.status }}
              </span>
            </p>
            <p><strong>Pojemność:</strong> {{ oxygenSystem.mainTank.capacity }} L</p>
            <p><strong>Ciśnienie:</strong> {{ oxygenSystem.mainTank.pressure }} bar</p>
            <p><strong>Przepływ:</strong> {{ oxygenSystem.flow.rate }} L/min</p>
            <p><strong>Konsumenci:</strong> {{ oxygenSystem.flow.consumers }}</p>
          </div>
          <div class="code-example">
            <pre>const system = reactive({
  mainTank: { level: 100 }
})
// Dostęp: system.mainTank.level
system.mainTank.level = 50</pre>
          </div>
        </div>
      </div>
    </div>

    <div class="controls">
      <button @click="startSimulation" class="btn btn-start">
        ▶START SYMULACJI
      </button>
      <button @click="stopSimulation" class="btn btn-stop">
        ⏸STOP
      </button>
      <button @click="refill" class="btn btn-refill">
        UZUPEŁNIJ
      </button>
    </div>

    <div class="info-box">
      <h3>Kiedy używać ref() vs reactive()?</h3>
      <div class="comparison-table">
        <div class="comparison-col">
          <h4>ref()</h4>
          <ul>
            <li>Wartości prymitywne (string, number, boolean)</li>
            <li>Gdy chcesz zastąpić całą wartość</li>
            <li>Łatwiejsze do debugowania</li>
            <li>Wymaga .value w script</li>
          </ul>
        </div>
        <div class="comparison-col">
          <h4>reactive()</h4>
          <ul>
            <li>Obiekty i tablice</li>
            <li>Grupowanie powiązanych danych</li>
            <li>Nie wymaga .value</li>
            <li>Nie można zastąpić całego obiektu</li>
          </ul>
        </div>
      </div>
    </div>
  </div>
</template>

<style scoped>
.oxygen-control {
  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-grid {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(350px, 1fr));
  gap: 2rem;
  margin-bottom: 2rem;
}

.section-title {
  color: #00b4d8;
  font-size: 1.3rem;
  margin-bottom: 1rem;
  text-align: center;
}

.card {
  background: #1a1f3a;
  padding: 1.5rem;
  border-radius: 8px;
  border: 1px solid #00b4d8;
}

.tank-visual {
  width: 100%;
  height: 200px;
  background: #0a0e27;
  border: 2px solid #00b4d8;
  border-radius: 8px;
  position: relative;
  overflow: hidden;
  margin-bottom: 1rem;
}

.tank-fill {
  position: absolute;
  bottom: 0;
  width: 100%;
  background: linear-gradient(180deg, #00ff88, #00b4d8);
  transition: height 0.3s ease;
  display: flex;
  align-items: center;
  justify-content: center;
}

.tank-fill.warning {
  background: linear-gradient(180deg, #ffaa00, #ff8800);
}

.tank-fill.critical {
  background: linear-gradient(180deg, #ff4444, #cc0000);
}

.tank-label {
  color: #0a0e27;
  font-weight: bold;
  font-size: 1.5rem;
  text-shadow: 0 0 5px rgba(255,255,255,0.5);
}

.tank-info {
  margin-bottom: 1rem;
}

.tank-info p {
  margin: 0.5rem 0;
  color: #ccc;
}

.status-optimal {
  color: #00ff88;
}

.status-warning {
  color: #ffaa00;
}

.status-critical {
  color: #ff4444;
  animation: blink 1s infinite;
}

@keyframes blink {
  0%, 50%, 100% { opacity: 1; }
  25%, 75% { opacity: 0.5; }
}

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

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

.controls {
  display: flex;
  gap: 1rem;
  margin-bottom: 2rem;
  justify-content: center;
  flex-wrap: wrap;
}

.btn {
  padding: 1rem 2rem;
  font-size: 1rem;
  border: none;
  border-radius: 8px;
  cursor: pointer;
  font-weight: bold;
  transition: all 0.3s ease;
  font-family: 'Courier New', monospace;
}

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

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

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

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

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

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

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

.comparison-col h4 {
  color: #00b4d8;
  margin-top: 0;
}

.comparison-col ul {
  padding-left: 1.5rem;
  color: #ccc;
}

.comparison-col li {
  margin: 0.5rem 0;
}
</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. Do czego służy reactive() w Vue 3?

  2. 2. Czy reactive() wymaga .value do odczytu właściwości?

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

Zadania praktyczne w grze

  • Edytor kodu

    Użyj reactive() do stworzenia obiektu z wieloma właściwościami i wyświetl je.

  • Układanie w poziomie

    Ułóż poprawną składnię tworzenia obiektu reactive:

  • Edytor kodu

    Stwórz reactive() i dodaj przyciski modyfikujące jego właściwości.

  • Klikanie w kolejności

    Ułóż kroki tworzenia i aktualizacji obiektu reactive:

  • Układanie w pionie

    Ułóż workflow pracy z reactive():

  1. PytanieFunkcja reactive()
  2. PytanieDostęp do reactive bez .value
  3. Zadanie z kodemPraktyka: Obiekt reactive()
  4. Ułóż w kolejnościSkładnia reactive()
  5. PytanieOgraniczenie reactive - reassignment
  6. Zadanie z kodemPraktyka: Modyfikacja reactive
  7. Kliknij w kolejnościTworzenie i mutacja reactive
  8. Pytanieref() vs reactive() - wartości prymitywne
  9. Ułóż w kolejnościWorkflow reactive()

Przydatne artykuły