Kurs Vue.js · Moduł 8: Sloty i komponenty dynamiczne

Async Components & Suspense

4 min czytania ·
W tej lekcji5

W NOVA LAB ciężkie moduły cargo nie są ładowane od razu - system ładuje je na żądanie, wyświetlając status na ekranie. Pomyśl o panelu z trójwymiarową mapą kraterów: jeśli jego kod trafi do głównej paczki aplikacji, każdy członek załogi zapłaci za niego czasem startu, nawet jeśli mapy nigdy nie otworzy. Vue oferuje async components - ładowanie komponentów lazy (na żądanie) i Suspense - kontrolę nad stanem ładowania.

defineAsyncComponent

Zamiast importować komponent bezpośrednio, możesz go załadować asynchronicznie. Funkcja defineAsyncComponent przyjmuje funkcję ładującą, która zwraca Promise z komponentem - najczęściej dynamiczny import(), dzięki któremu bundler, na przykład Vite, wydziela komponent do osobnego pliku:

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

// Prosty lazy import
const HeavyModule = defineAsyncComponent(
  () => import('./HeavyModule.vue')
)
</script>

<template>
  <HeavyModule />
</template>

Komponent jest pobierany dopiero wtedy, gdy jest potrzebny, czyli przy pierwszym renderowaniu w template. Dla szablonu HeavyModule wygląda jak zwykły komponent, przyjmuje props i emituje zdarzenia - zmienił się tylko moment pobrania kodu.

Zaawansowana konfiguracja

Zamiast samej funkcji możesz przekazać obiekt opcji. Oprócz loader określasz w nim, co pokazać w trakcie ładowania, po jakim czasie to zrobić i co wyświetlić, gdy transport modułu się nie powiedzie:

<script setup>
import { defineAsyncComponent } from 'vue'
import LoadingSpinner from './LoadingSpinner.vue'
import ErrorDisplay from './ErrorDisplay.vue'

const HeavyModule = defineAsyncComponent({
  // Funkcja ładująca
  loader: () => import('./HeavyModule.vue'),

  // Komponent wyświetlany podczas ładowania
  loadingComponent: LoadingSpinner,

  // Opóźnienie przed wyświetleniem loading (ms)
  delay: 200,

  // Komponent wyświetlany gdy ładowanie się nie powiedzie
  errorComponent: ErrorDisplay,

  // Timeout - po tym czasie wyświetli error (ms)
  timeout: 10000
})
</script>

Kolejność zdarzeń wygląda tak: Vue wywołuje loader, odczekuje delay, a jeśli moduł wciąż nie dotarł, pokazuje loadingComponent. Gdy import się zakończy, spinner zostaje zastąpiony właściwym komponentem. Wartość 200 ms to zresztą domyślne delay - na szybkim łączu spinner mignąłby tylko na ułamek sekundy. Domyślny timeout jest nieskończony, więc bez tej opcji errorComponent pojawi się tylko przy błędzie importu.

Suspense

<Suspense> to wbudowany komponent Vue do zarządzania stanem ładowania całego drzewa asynchronicznych komponentów naraz. Uwaga: w Vue 3.5 wciąż jest oznaczony jako funkcja eksperymentalna - jego API może się jeszcze zmienić, a Vue przypomina o tym komunikatem w konsoli. Ma dwa sloty, #default i #fallback:

<template>
  <Suspense>
    <!-- Treść główna (ładowany komponent) -->
    <template #default>
      <HeavyModule />
    </template>

    <!-- Loading state -->
    <template #fallback>
      <div class="loading">
        <p>Loading module...</p>
        <div class="spinner"></div>
      </div>
    </template>
  </Suspense>
</template>

Przy pierwszym renderze Suspense renderuje treść #default w pamięci. Wtedy async komponent rozpoczyna ładowanie, a Suspense przechodzi w stan oczekiwania i wyświetla #fallback. Gdy wszystkie asynchroniczne zależności się zakończą, przełącza się na #default. Ważny szczegół: wewnątrz Suspense własne opcje loadingComponent, errorComponent, delay i timeout komponentu asynchronicznego są ignorowane, bo stanem ładowania steruje Suspense. Jeśli komponent ma zachować własny spinner, dodaj mu opcję suspensible: false.

Suspense events

Suspense emituje zdarzenia informujące o stanie ładowania: pending przy wejściu w stan oczekiwania, fallback przy wyświetleniu treści zastępczej i resolve, gdy treść główna jest gotowa:

<template>
  <Suspense
    @pending="onPending"
    @resolve="onResolve"
    @fallback="onFallback"
  >
    <template #default>
      <AsyncModule />
    </template>
    <template #fallback>
      <LoadingSpinner />
    </template>
  </Suspense>
</template>

<script setup>
const onPending = () => console.log('Loading started...')
const onResolve = () => console.log('Loading complete!')
const onFallback = () => console.log('Fallback displayed')
</script>

Przy pierwszym ładowaniu konsola pokaże kolejno "Loading started...", "Fallback displayed" i "Loading complete!". To dobre miejsce na pomiar czasu ładowania albo wpis do dziennika stacji.

Async setup w komponentach

Komponent z async setup lub top-level await w <script setup> automatycznie staje się asynchroniczną zależnością dla Suspense:

<!-- AsyncModule.vue -->
<script setup>
const data = await fetch('/api/module-data')
  .then(r => r.json())
</script>

<template>
  <div>{{ data.name }}</div>
</template>

Taki komponent musi mieć nad sobą <Suspense>. Bez niego Vue wypisze ostrzeżenie i nie wyrenderuje go wcale. Suspense nie obsługuje też błędów samodzielnie - odrzucony fetch przechwycisz w komponencie nadrzędnym hookiem onErrorCaptured.

Moja rada: w kodzie produkcyjnym zacznij od defineAsyncComponent z loadingComponent i errorComponent, bo to stabilne API. Suspense stosuj tam, gdzie kilka komponentów ładuje się naraz i chcesz jednego wspólnego ekranu oczekiwania, pamiętając o jego eksperymentalnym statusie. W edytorze poniżej przycisk ładuje HeavyModule z symulowanym dwusekundowym opóźnieniem, a po 200 ms pojawia się LoadingSpinner.

Zapamiętaj: ciężki moduł dolatuje na stację dopiero wtedy, gdy ktoś go potrzebuje, a Suspense trzyma ekran oczekiwania, dopóki nie dotrze cały ładunek.

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

// Symulacja async component (w prawdziwej apce: import('./Heavy.vue'))
const HeavyModule = defineAsyncComponent({
  loader: () => new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        template: `
          <div class="heavy-module">
            <h2>Ciężki moduł załadowany!</h2>
            <p>Złożona wizualizacja danych gotowa</p>
            <div class="chart">
              <div v-for="h in [80, 60, 90, 45, 75]" :key="h"
                class="bar" :style="{ height: h + 'px' }">
              </div>
            </div>
          </div>
        `
      })
    }, 2000)
  }),
  loadingComponent: LoadingSpinner,
  delay: 200
})

const showModule = ref(false)
</script>

<template>
  <div class="nova-lab">
    <h1>Async Components & Suspense</h1>

    <button @click="showModule = !showModule" class="btn">
      {{ showModule ? 'Ukryj' : 'Załaduj' }} ciężki moduł
    </button>

    <div v-if="showModule" class="container">
      <HeavyModule />
    </div>
  </div>
</template>

<style scoped>
.nova-lab {
  background: #0a0e27;
  color: #00ff88;
  min-height: 100vh;
  padding: 20px;
  font-family: monospace;
}
h1 { color: #00ff88; margin-bottom: 20px; }
.btn {
  background: #00b4d8;
  color: #0a0e27;
  border: none;
  padding: 12px 24px;
  cursor: pointer;
  font-family: monospace;
  font-weight: bold;
  font-size: 14px;
}
.container {
  margin-top: 20px;
  border: 2px solid #00b4d8;
  padding: 20px;
}
</style>

<style>
.heavy-module h2 { color: #00ff88; margin-bottom: 10px; }
.heavy-module .chart {
  display: flex;
  align-items: flex-end;
  gap: 8px;
  margin-top: 15px;
  height: 100px;
}
.heavy-module .bar {
  width: 30px;
  background: #00b4d8;
}
</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 defineAsyncComponent w Vue?

  2. 2. Który slot w <Suspense> wyświetla treść podczas ładowania?

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj etapy działania Suspense:

  • Edytor kodu

    Użyj defineAsyncComponent do lazy loadingu komponentu HeavyModule. Wyświetl 'Loading...' podczas ładowania.

  • Układanie w poziomie

    Ułóż kod definicji async komponentu:

  • Klikanie w kolejności

    Ułóż kod Suspense z async komponentem:

  • Edytor kodu

    Użyj <Suspense> z #default i #fallback slotami do wyświetlenia async komponentu z loading spinnerem.

  1. PytaniedefineAsyncComponent
  2. Ułóż w kolejnościPrzepływ Suspense
  3. Zadanie z kodemPraktyka: Async component
  4. Ułóż w kolejnościSkładnia defineAsyncComponent
  5. PytanieSuspense fallback slot
  6. Kliknij w kolejnościSkładnia Suspense z komponentem
  7. Zadanie z kodemPraktyka: Suspense

Przydatne artykuły