Kurs Vue.js · Moduł 6: Komponenty

Composables - Wielokrotne Użycie Logiki

6 min czytania ·
W tej lekcji7

Dr. Nova wyjaśnia: "W NOVA LAB wiele modułów potrzebuje tych samych systemów - timer misji, odczyty sensorów, połączenie z bazą danych. Zamiast kopiować ten sam kod do każdego modułu, tworzymy współdzielone systemy. W Vue takim systemem jest composable."

Pięć paneli stacji pokazuje czas misji. Jeśli każdy ma własną kopię kodu z setInterval, onMounted i onUnmounted, to poprawka błędu w liczeniu czasu oznacza edycję pięciu plików, a przeoczenie jednego - pięć różnych zegarów na jednej stacji.

Czym Jest Composable?

Composable to funkcja, która enkapsuluje i zwraca reaktywny stan oraz logikę. Pozwala współdzielić logikę między wieloma komponentami bez duplikowania kodu. Dokumentacja Vue opisuje go jako funkcję korzystającą z Composition API, czyli z ref, computed albo hooków cyklu życia.

Konwencja nazewnictwa: composable zawsze zaczyna się od use - np. useTimer, useCounter, useMarsData. Najprostszy przykład to licznik złożony z kontenera, trzech funkcji i obiektu, który je zwraca:

// composables/useCounter.js
import { ref } from 'vue'

export function useCounter(initialValue = 0) {
  const count = ref(initialValue)

  function increment() {
    count.value++
  }

  function decrement() {
    count.value--
  }

  function reset() {
    count.value = initialValue
  }

  // Zwracamy reaktywny stan i funkcje
  return { count, increment, decrement, reset }
}

To zwykła funkcja JavaScript eksportowana z pliku .js - bez szablonu i bez stylów. Zwraca zwykły obiekt z kontenerami i funkcjami, więc komponent może go rozpakować, a count pozostanie reaktywny. Parametr initialValue = 0 ma wartość domyślną, więc useCounter() bez argumentu zacznie od zera.

Używanie Composable w Komponencie

W komponencie importujesz funkcję i wywołujesz ją w <script setup>, a zwrócone wartości rozpakowujesz destrukturyzacją:

<template>
  <div style="background: #0a0e27; color: #00ff88; padding: 1rem;">
    <h3>Licznik modułów: {{ count }}</h3>
    <button @click="increment">+1</button>
    <button @click="decrement">-1</button>
    <button @click="reset">Reset</button>
  </div>
</template>

<script setup>
import { useCounter } from './composables/useCounter'

// Destrukturyzacja zwróconych wartości
const { count, increment, decrement, reset } = useCounter(10)
</script>

Każdy komponent, który użyje useCounter(), dostaje własną, niezależną instancję stanu. Zmiana count w jednym komponencie nie wpływa na inny. Wywołuj composables synchronicznie, na najwyższym poziomie <script setup>, a nie na przykład w funkcji obsługi kliknięcia - tylko wtedy Vue powiąże je z komponentem.

Organizacja Plików

Composables przechowujemy w dedykowanym folderze, oddzielnie od komponentów, które z nich korzystają:

src/
├── composables/
│   ├── useTimer.js
│   ├── useCounter.js
│   ├── useFetch.js
│   └── useMarsData.js
├── components/
│   ├── StatusBar.vue
│   └── ModuleCard.vue
└── App.vue

Najczęściej jest to src/composables/ - tak nazywa ten katalog również Nuxt. Czasem spotkasz src/hooks/, nazwę pożyczoną z Reacta. Vue niczego tu nie narzuca, ważne tylko, żeby cały projekt trzymał się jednej konwencji.

Praktyczny Composable: useTimer

Timer misji to typowy composable używany w wielu komponentach stacji, bo łączy stan, wartość wyliczaną i hooki cyklu życia:

// composables/useTimer.js
import { ref, computed, onMounted, onUnmounted } from 'vue'

export function useTimer() {
  const seconds = ref(0)
  let intervalId = null

  const formatted = computed(() => {
    const h = String(Math.floor(seconds.value / 3600)).padStart(2, '0')
    const m = String(Math.floor((seconds.value % 3600) / 60)).padStart(2, '0')
    const s = String(seconds.value % 60).padStart(2, '0')
    return `${h}:${m}:${s}`
  })

  function start() {
    intervalId = setInterval(() => {
      seconds.value++
    }, 1000)
  }

  function stop() {
    if (intervalId) {
      clearInterval(intervalId)
      intervalId = null
    }
  }

  // Automatyczne zarządzanie cyklem życia
  onMounted(() => start())
  onUnmounted(() => stop())

  return { seconds, formatted, start, stop }
}

Hooki wywołane w composable podpinają się pod komponent, który wywołał useTimer(), więc zegar startuje razem z nim i zatrzymuje się przy jego demontażu. Metoda padStart(2, '0') dopisuje zero z przodu, żeby 7 sekund wyglądało jak 07. Zwróć uwagę na import: computed trzeba sprowadzić z vue tak samo jak ref, inaczej kod przerwie się błędem. Komponent, który potrzebuje zegara, bierze z funkcji tylko to, czego potrzebuje:

<!-- Użycie w dowolnym komponencie -->
<template>
  <p>Czas misji: {{ formatted }}</p>
</template>

<script setup>
import { useTimer } from './composables/useTimer'

const { formatted } = useTimer()
</script>

Komponent nie wie nic o setInterval ani o sprzątaniu - dostaje gotowy, sformatowany czas.

Composable: useFetch

Pobieranie danych to kolejny typowy wzorzec: trzy kontenery opisują stan zapytania, a jedna funkcja je wykonuje:

// composables/useFetch.js
import { ref } from 'vue'

export function useFetch(url) {
  const data = ref(null)
  const error = ref(null)
  const loading = ref(false)

  async function fetchData() {
    loading.value = true
    error.value = null

    try {
      const response = await fetch(url)
      data.value = await response.json()
    } catch (err) {
      error.value = err.message
    } finally {
      loading.value = false
    }
  }

  return { data, error, loading, fetchData }
}

Kontener loading ma wartość true przez cały czas zapytania, error przechowuje komunikat błędu, a blok finally wyłącza ładowanie niezależnie od wyniku. Samo wywołanie useFetch() niczego nie pobiera - robi to dopiero fetchData(). W komponencie wywołujemy ją w onMounted, a szablon wybiera jeden z trzech stanów dyrektywami v-if, v-else-if i v-else:

<template>
  <div>
    <p v-if="loading">Ładowanie danych stacji...</p>
    <p v-else-if="error">Błąd: {{ error }}</p>
    <ul v-else-if="data">
      <li v-for="module in data" :key="module.id">{{ module.name }}</li>
    </ul>
  </div>
</template>

<script setup>
import { onMounted } from 'vue'
import { useFetch } from './composables/useFetch'

const { data, error, loading, fetchData } = useFetch('/api/modules')

onMounted(() => fetchData())
</script>

Ten sam useFetch obsłuży listę modułów, pogodę na Marsie czy raport załogi - zmienia się tylko adres.

Dlaczego Composables?

Bez composablesZ composables
Kopiujesz ten sam kod timera do 5 komponentówJeden useTimer(), importowany wszędzie
Zmiana logiki = edycja 5 plikówZmiana w jednym pliku
Trudne testowanie (logika w komponentach)Łatwiejsze testowanie (logika w osobnych funkcjach)
Komponenty pełne powtarzającego się koduKomponenty skupione na wyświetlaniu

Composable korzystający tylko z ref i computed przetestujesz, wywołując go wprost w teście, a ten z hookami cyklu życia potrzebuje komponentu-gospodarza - wrócimy do tego w Laboratorium Naukowym.

Plan Budowy Stacji

W NOVA LAB aplikację z komponentów budujemy w stałej kolejności: planujemy strukturę komponentów, tworzymy komponenty bazowe, takie jak przycisk czy karta, wydzielamy logikę do composables, składamy komponenty w widoki, a na końcu dopinamy hooki cyklu życia i style. Ten porządek polecam Ci bo każdy krok opiera się na poprzednim. W edytorze poniżej komponent MarsStation korzysta z useMarsData i useTimer - otwórz ich pliki i odszukaj wzorce z tej lekcji.

Zapamiętaj: composable to wspólny system stacji - funkcja use..., która zwraca reaktywny stan i logikę, a każdy moduł podłącza się do niej niezależnie.

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

const stationName = ref('NOVA LAB Alpha')
</script>

<template>
  <div class="composables-lab">
    <div class="header">
      <h1>Composables - NOVA LAB</h1>
      <p class="subtitle">Wielokrotne uzycie logiki z composables</p>
    </div>

    <div class="info-panel">
      <h3>Czym sa composables?</h3>
      <p><strong>Composable</strong> to funkcja zaczynajaca sie od <strong>use</strong> (np. useMarsData)</p>
      <p>Kapsulkuje reaktywny stan (ref) i logike, ktora mozna wspoldzielic miedzy komponentami</p>
      <p>Struktura: export function useXxx() { const state = ref(...); return { state } }</p>
    </div>

    <MarsStation :station-name="stationName" />
  </div>
</template>

<style scoped>
.composables-lab {
  background: linear-gradient(135deg, #0a0e27 0%, #1a1e3f 100%);
  min-height: 100vh;
  padding: 2rem;
  color: #ffffff;
  font-family: 'Courier New', monospace;
}

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

.header h1 {
  font-size: 2rem;
  color: #00ff88;
  text-shadow: 0 0 20px rgba(0, 255, 136, 0.5);
  margin: 0;
}

.subtitle {
  color: #00b4d8;
  font-size: 1.1rem;
  margin-top: 0.5rem;
}

.info-panel {
  background: rgba(0, 180, 216, 0.1);
  border: 2px solid #00b4d8;
  border-radius: 10px;
  padding: 1.5rem;
  margin-bottom: 2rem;
}

.info-panel h3 {
  color: #00b4d8;
  margin-top: 0;
}

.info-panel strong {
  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. Co to jest composable w Vue 3?

  2. 2. Jak powinna nazywać się composable zgodnie z konwencją Vue?

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

Zadania praktyczne w grze

  • Edytor kodu

    Utwórz composable useMarsWeather z reaktywnymi danymi i funkcją fetch.

  • Klikanie w kolejności

    Ułóż elementy struktury composable w kolejności:

  • Układanie w pionie

    Ułóż kroki użycia composable w komponencie:

  • Edytor kodu

    Importuj i użyj composable useMarsWeather w komponencie WeatherPanel.vue.

  • Układanie w pionie

    Ułóż etapy tworzenia i testowania composable od pliku do użycia:

  • Klikanie w kolejności

    Ułóż kroki od stworzenia do użycia composable:

  • Edytor kodu

    Stwórz MarsColony z zagnieżdżonymi komponentami HabitatModule, LabModule i StorageModule.

  • Układanie w pionie

    Ułóż proces od stworzenia do wyświetlenia komponentu:

  • Układanie w pionie

    Ułóż hooki w kolejności wywołania przy montowaniu komponentu:

  • Edytor kodu

    Stwórz zestaw komponentów: MarsButton i MarsCard z odpowiednimi stylami.

  • Klikanie w kolejności

    Ułóż składnię użycia v-bind() w sekcji style:

  • Układanie w pionie

    Ułóż kroki dodania lifecycle hooka do komponentu:

  • Układanie w poziomie

    Ułóż składnię użycia klasy CSS Module w template:

  • Edytor kodu

    Użyj composable useMarsData z onMounted do inicjalizacji danych w komponencie Dashboard.

  • Układanie w pionie

    Ułóż etapy budowania aplikacji z komponentów:

  • Układanie w poziomie

    Ułóż poprawny import ref i onMounted z Vue:

  • Klikanie w kolejności

    Ułóż composable z onMounted:

  • Układanie w pionie

    Ułóż metody stylowania od najszerszego do najwęższego zakresu:

  • Układanie w poziomie

    Ułóż poprawną składnię użycia onMounted:

  1. PytanieCzym jest composable?
  2. PytanieKonwencja nazw composables
  3. Zadanie z kodemPraktyka: Tworzenie composable
  4. Kliknij w kolejnościStruktura composable
  5. PytanieLokalizacja plików composables
  6. Ułóż w kolejnościUżycie composable w komponencie
  7. Zadanie z kodemPraktyka: Composable w komponencie
  8. PytanieStruktura projektu Vue
  9. PytanieNazwy plików komponentów
  10. Ułóż w kolejnościProces tworzenia composable
  11. PytanieMulti-word nazwy komponentów
  12. Kliknij w kolejnościImport composable i użycie
  13. Zadanie z kodemPraktyka: Zagnieżdżone komponenty
  14. Ułóż w kolejnościProces tworzenia i użycia komponentu
  15. PytanieFolder komponentów
  16. Ułóż w kolejnościOpis lifecycle hooks
  17. Zadanie z kodemPraktyka: Biblioteka komponentów
  18. Kliknij w kolejnościUżycie v-bind w CSS
  19. Ułóż w kolejnościProces obsługi lifecycle
  20. PytanieReaktywne style z v-bind
  21. Ułóż w kolejnościDeklaracja CSS Module w template
  22. Zadanie z kodemPraktyka: Composable z lifecycle
  23. Ułóż w kolejnościPełny proces budowania aplikacji komponentowej
  24. Ułóż w kolejnościElementy importu z vue
  25. Kliknij w kolejnościDeklaracja composable z onMounted
  26. Ułóż w kolejnościPoziomy izolacji stylów
  27. Ułóż w kolejnościSkładnia onMounted

Przydatne artykuły