Kurs Vue.js · Moduł 9: Composables i VueUse
Projekt: Lab Manager z Composables
W tej lekcji4
Kompleksowy system zarządzania laboratorium NOVA LAB wykorzystujący wszystkie poznane techniki! Dr. Nova potrzebuje panelu, który pobierze listę eksperymentów z serwera, pozwoli ją przeszukiwać, filtrować i sortować, podzieli wyniki na strony i umożliwi usuwanie wpisów. Gdybyś wpisał to wszystko do jednego komponentu, dostałbyś kilkaset linii, w których pobieranie danych miesza się z paginacją. Zamiast tego zbudujemy trzy composables, z których każdy ma jedno zadanie, i komponent, który je łączy. Dane płyną jedną drogą: useExperiments() pobiera i przechowuje eksperymenty, useLabFilters(experiments) je filtruje, usePagination(filtered) dzieli wynik na strony, a template wyświetla paginatedItems.
Warstwa danych: useExperiments
Pierwszy plik, composables/useExperiments.js, odpowiada za dane. Zwraca stan, flagi loading i error oraz funkcje CRUD - od angielskiego Create, Read, Update, Delete, czyli tworzenie, odczyt, aktualizację i usuwanie. Wartości pochodne, takie jak lista krytycznych eksperymentów i liczba kategorii, wyliczają computed:
// composables/useExperiments.js
import { ref, computed } from 'vue'
export function useExperiments() {
const experiments = ref([])
const loading = ref(false)
const error = ref(null)
const criticalExperiments = computed(() =>
experiments.value.filter(exp => exp.critical)
)
const categoriesCount = computed(() =>
new Set(experiments.value.map(exp => exp.category)).size
)
async function fetchExperiments() {
loading.value = true
error.value = null
try {
const response = await fetch('/api/mars/experiments')
if (!response.ok) throw new Error('Błąd pobierania')
experiments.value = await response.json()
} catch (e) {
error.value = e.message
} finally {
loading.value = false
}
}
async function addExperiment(experiment) {
const response = await fetch('/api/mars/experiments', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(experiment)
})
const newExperiment = await response.json()
experiments.value.push(newExperiment)
}
async function deleteExperiment(id) {
await fetch(`/api/mars/experiments/${id}`, { method: 'DELETE' })
experiments.value = experiments.value.filter(exp => exp.id !== id)
}
return {
experiments,
loading,
error,
criticalExperiments,
categoriesCount,
fetchExperiments,
addExperiment,
deleteExperiment
}
}Mamy odczyt, tworzenie i usuwanie; aktualizację dopiszesz w ramach rozbudowy. Warto też od razu dodać dwie rzeczy z poprzednich lekcji: sprawdzenie response.ok w addExperiment oraz AbortController, który anuluje pobieranie przy odmontowaniu.
Filtrowanie: useLabFilters
Drugi composable przyjmuje parametr - ref z listą eksperymentów - i buduje z niego przefiltrowaną, posortowaną wersję. Nie wie nic o serwerze, więc zadziała z każdą listą o polach name i category:
// composables/useLabFilters.js
import { ref, computed } from 'vue'
export function useLabFilters(experiments) {
const searchQuery = ref('')
const selectedCategory = ref('')
const sortBy = ref('name')
const sortOrder = ref('asc')
const filteredExperiments = computed(() => {
let result = experiments.value
// Search
if (searchQuery.value) {
const query = searchQuery.value.toLowerCase()
result = result.filter(exp =>
exp.name.toLowerCase().includes(query) ||
exp.category.toLowerCase().includes(query)
)
}
// Filter by category
if (selectedCategory.value) {
result = result.filter(exp => exp.category === selectedCategory.value)
}
// Sort
result = [...result].sort((a, b) => {
const aVal = a[sortBy.value]
const bVal = b[sortBy.value]
const order = sortOrder.value === 'asc' ? 1 : -1
if (typeof aVal === 'string') {
return aVal.localeCompare(bVal) * order
}
return (aVal - bVal) * order
})
return result
})
const uniqueCategories = computed(() =>
[...new Set(experiments.value.map(exp => exp.category))].sort()
)
function resetFilters() {
searchQuery.value = ''
selectedCategory.value = ''
sortBy.value = 'name'
sortOrder.value = 'asc'
}
return {
searchQuery,
selectedCategory,
sortBy,
sortOrder,
filteredExperiments,
uniqueCategories,
resetFilters
}
}Zwróć uwagę na [...result].sort: metoda sort zmienia tablicę w miejscu, więc bez kopii posortowalibyśmy oryginalną listę z useExperiments. Napisy porównuje localeCompare, a liczby, na przykład rok, zwykłe odejmowanie.
Paginacja: usePagination
Trzeci composable dzieli dowolną listę na strony. Liczbę stron wylicza computed z Math.ceil, a bieżący wycinek - slice:
// composables/usePagination.js
import { ref, computed } from 'vue'
export function usePagination(items, itemsPerPage = 12) {
const currentPage = ref(1)
const perPage = ref(itemsPerPage)
const totalPages = computed(() =>
Math.ceil(items.value.length / perPage.value)
)
const paginatedItems = computed(() => {
const start = (currentPage.value - 1) * perPage.value
const end = start + perPage.value
return items.value.slice(start, end)
})
function goToPage(page) {
if (page >= 1 && page <= totalPages.value) {
currentPage.value = page
}
}
function nextPage() {
goToPage(currentPage.value + 1)
}
function prevPage() {
goToPage(currentPage.value - 1)
}
return {
currentPage,
perPage,
totalPages,
paginatedItems,
goToPage,
nextPage,
prevPage
}
}goToPage ignoruje numery spoza zakresu. Jedna pułapka: jeśli jesteś na stronie 3 i zawęzisz filtr do jednej strony wyników, currentPage zostanie na 3, a lista pokaże się pusta. Poprawka to jedna linijka w composable, plus import watch: watch(items, () => { currentPage.value = 1 }).
Komponent LabManager
Czas połączyć moduły w panelu. Pierwsza część szablonu to nagłówek z licznikami i panel filtrów, w którym v-model wiąże pola formularza z refami z useLabFilters:
<!-- LabManager.vue -->
<template>
<div class="lab-manager">
<!-- Header -->
<header>
<h1>NOVA LAB - Zarządzanie Eksperymentami</h1>
<p>{{ categoriesCount }} kategorii, {{ experiments.length }} eksperymentów</p>
</header>
<!-- Filters -->
<aside class="filters">
<input v-model="searchQuery" placeholder="Szukaj eksperymentów..." />
<select v-model="selectedCategory">
<option value="">Wszystkie kategorie</option>
<option v-for="category in uniqueCategories" :key="category" :value="category">
{{ category }}
</option>
</select>
<select v-model="sortBy">
<option value="name">Nazwa</option>
<option value="category">Kategoria</option>
<option value="year">Rok</option>
</select>
<button @click="sortOrder = sortOrder === 'asc' ? 'desc' : 'asc'">
{{ sortOrder === 'asc' ? '↑' : '↓' }}
</button>
<button @click="resetFilters">Resetuj</button>
</aside>Każda zmiana w polu wyszukiwania od razu przelicza filteredExperiments, a za nią paginatedItems - bez jednej linii kodu obsługi zdarzeń. Druga część pokazuje stan ładowania, siatkę kart i paginację. Komponent ExperimentCard pomijamy - wyświetla kartę eksperymentu i emituje zdarzenie delete:
<!-- Loading/Error -->
<div v-if="loading">Ładowanie eksperymentów...</div>
<div v-else-if="error">Błąd: {{ error }}</div>
<!-- Lab Dashboard -->
<main v-else class="lab-grid">
<ExperimentCard
v-for="experiment in paginatedItems"
:key="experiment.id"
:experiment="experiment"
@delete="deleteExperiment(experiment.id)"
/>
</main>
<!-- Pagination -->
<footer class="pagination">
<button @click="prevPage" :disabled="currentPage === 1">
Poprzednia
</button>
<button
v-for="page in totalPages"
:key="page"
@click="goToPage(page)"
:class="{ active: currentPage === page }"
>
{{ page }}
</button>
<button @click="nextPage" :disabled="currentPage === totalPages">
Następna
</button>
</footer>
</div>
</template>v-for="page in totalPages" iteruje po liczbie, więc daje kolejno 1, 2, 3 aż do totalPages. Na koniec skrypt, w którym importujesz composables, destrukturyzujesz zwrócone API i przekazujesz wynik jednego jako parametr następnego:
<script setup>
import { onMounted } from 'vue'
import { useExperiments } from './composables/useExperiments'
import { useLabFilters } from './composables/useLabFilters'
import { usePagination } from './composables/usePagination'
// Composables
const {
experiments,
loading,
error,
categoriesCount,
fetchExperiments,
deleteExperiment
} = useExperiments()
const {
searchQuery,
selectedCategory,
sortBy,
sortOrder,
filteredExperiments,
uniqueCategories,
resetFilters
} = useLabFilters(experiments)
const {
currentPage,
totalPages,
paginatedItems,
goToPage,
nextPage,
prevPage
} = usePagination(filteredExperiments, 12)
// Lifecycle
onMounted(() => {
fetchExperiments()
})
</script>Kolejność wywołań odzwierciedla przepływ danych: experiments trafia do filtrów, filteredExperiments do paginacji, a dane pobieramy w onMounted. Komponent nie zawiera żadnej logiki biznesowej - tylko ją skleja.
Moja rada: pilnuj zasady jednego zadania na composable. Dzięki niej usePagination użyjesz w dowolnej innej liście stacji, a każdy composable przetestujesz osobno, jak w lekcji o testowaniu. W edytorze poniżej czeka pokrewny przykład integracji modułów: useTimer, useModuleStatus i useNotifications łączą się w jeden panel według tej samej zasady.
Zapamiętaj: Lab Manager to stacja zbudowana z modułów - każdy composable robi jedną rzecz, a komponent tylko je ze sobą łączy.
Kod do tej lekcji: App.vue
<script setup>
import { ref, computed, watch, onMounted } from 'vue'
// Dobra praktyka 1: jedna odpowiedzialność
function useTimer(initialSeconds = 0) {
const seconds = ref(initialSeconds)
const isRunning = ref(false)
let intervalId = null
const formattedTime = computed(() => {
const mins = Math.floor(seconds.value / 60)
const secs = seconds.value % 60
return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`
})
function start() {
if (isRunning.value) return
isRunning.value = true
intervalId = setInterval(() => {
seconds.value++
}, 1000)
}
function pause() {
isRunning.value = false
if (intervalId) {
clearInterval(intervalId)
intervalId = null
}
}
function reset() {
pause()
seconds.value = initialSeconds
}
return {
seconds,
formattedTime,
isRunning,
start,
pause,
reset
}
}
// Dobra praktyka 2: kompozycja composables
function useModuleStatus(moduleName) {
const isOnline = ref(true)
const temperature = ref(22)
const powerConsumption = ref(45)
const status = computed(() => {
if (!isOnline.value) return { level: 'offline', color: '#666666' }
if (temperature.value > 80) return { level: 'krytyczny', color: '#ff0055' }
if (powerConsumption.value > 80) return { level: 'ostrzeżenie', color: '#ffb400' }
return { level: 'optymalny', color: '#00ff88' }
})
// Używamy composable timera
const uptime = useTimer()
// Licznik czasu pracy startuje sam, gdy moduł jest online
watch(isOnline, (newValue) => {
if (newValue) {
uptime.start()
} else {
uptime.pause()
}
}, { immediate: true })
function toggleOnline() {
isOnline.value = !isOnline.value
}
function adjustTemperature(delta) {
temperature.value = Math.max(0, Math.min(100, temperature.value + delta))
}
function adjustPower(delta) {
powerConsumption.value = Math.max(0, Math.min(100, powerConsumption.value + delta))
}
return {
moduleName: ref(moduleName),
isOnline,
temperature,
powerConsumption,
status,
uptime,
toggleOnline,
adjustTemperature,
adjustPower
}
}
// Dobra praktyka 3: opcje z wartościami domyślnymi
function useNotifications(options = {}) {
const {
maxNotifications = 10,
autoRemove = true,
autoRemoveDelay = 5000
} = options
const notifications = ref([])
let notificationId = 0
function add(message, type = 'info') {
notificationId++
const notification = {
id: notificationId,
message,
type,
timestamp: new Date()
}
notifications.value.unshift(notification)
if (notifications.value.length > maxNotifications) {
notifications.value.pop()
}
if (autoRemove) {
setTimeout(() => {
remove(notification.id)
}, autoRemoveDelay)
}
return notification
}
function remove(id) {
const index = notifications.value.findIndex(n => n.id === id)
if (index !== -1) {
notifications.value.splice(index, 1)
}
}
function clear() {
notifications.value = []
}
return {
notifications,
add,
remove,
clear
}
}
// Inicjalizacja modułów
const habitatModule = useModuleStatus('Moduł mieszkalny')
const researchModule = useModuleStatus('Moduł badawczy')
const powerModule = useModuleStatus('Moduł energetyczny')
// Inicjalizacja powiadomień
const notify = useNotifications({
maxNotifications: 5,
autoRemove: true,
autoRemoveDelay: 4000
})
// Symulacja zdarzeń w modułach
function simulateHeatWave(module) {
module.adjustTemperature(30)
notify.add(`Wykryto falę ciepła: ${module.moduleName.value}`, 'warning')
}
function simulateCooling(module) {
module.adjustTemperature(-20)
notify.add(`Włączono chłodzenie: ${module.moduleName.value}`, 'info')
}
function simulatePowerSpike(module) {
module.adjustPower(40)
notify.add(`Skok mocy: ${module.moduleName.value}`, 'warning')
}
onMounted(() => {
notify.add('System integracji modułów NOVA LAB działa', 'success')
})
</script>
<template>
<div class="integration-lab">
<div class="header">
<h1>Integracja Modułów - NOVA LAB</h1>
<p class="subtitle">Moduł 6: dobre praktyki i wzorce composables</p>
</div>
<!-- Panel powiadomień -->
<div class="notifications-panel">
<div class="notifications-header">
<h3>Powiadomienia systemu</h3>
<button @click="notify.clear()" class="btn btn-sm btn-danger">Wyczyść wszystko</button>
</div>
<div class="notifications-list">
<div
v-for="notification in notify.notifications.value"
:key="notification.id"
class="notification"
:class="'notification-' + notification.type"
>
<span class="notification-type">{{ notification.type.toUpperCase() }}</span>
<span class="notification-message">{{ notification.message }}</span>
<button @click="notify.remove(notification.id)" class="btn-close">×</button>
</div>
</div>
</div>
<!-- Siatka modułów -->
<div class="modules-grid">
<!-- Moduł mieszkalny -->
<div class="module-card" :style="{ borderColor: habitatModule.status.value.color }">
<div class="module-header">
<h3>{{ habitatModule.moduleName.value }}</h3>
<div
class="status-badge"
:style="{ background: habitatModule.status.value.color }"
>
{{ habitatModule.status.value.level.toUpperCase() }}
</div>
</div>
<div class="module-stats">
<div class="stat">
<span class="stat-label">Temperatura:</span>
<span class="stat-value">{{ habitatModule.temperature.value }}°C</span>
</div>
<div class="stat">
<span class="stat-label">Moc:</span>
<span class="stat-value">{{ habitatModule.powerConsumption.value }}%</span>
</div>
<div class="stat">
<span class="stat-label">Czas pracy:</span>
<span class="stat-value">{{ habitatModule.uptime.formattedTime.value }}</span>
</div>
</div>
<div class="module-controls">
<button
@click="habitatModule.toggleOnline()"
class="btn"
:class="habitatModule.isOnline.value ? 'btn-warning' : 'btn-success'"
>
{{ habitatModule.isOnline.value ? 'Wyłącz' : 'Włącz' }}
</button>
</div>
<div class="module-simulations">
<button @click="simulateHeatWave(habitatModule)" class="btn btn-sm">Fala ciepła</button>
<button @click="simulateCooling(habitatModule)" class="btn btn-sm">Chłodzenie</button>
<button @click="simulatePowerSpike(habitatModule)" class="btn btn-sm">Skok mocy</button>
</div>
</div>
<!-- Moduł badawczy -->
<div class="module-card" :style="{ borderColor: researchModule.status.value.color }">
<div class="module-header">
<h3>{{ researchModule.moduleName.value }}</h3>
<div
class="status-badge"
:style="{ background: researchModule.status.value.color }"
>
{{ researchModule.status.value.level.toUpperCase() }}
</div>
</div>
<div class="module-stats">
<div class="stat">
<span class="stat-label">Temperatura:</span>
<span class="stat-value">{{ researchModule.temperature.value }}°C</span>
</div>
<div class="stat">
<span class="stat-label">Moc:</span>
<span class="stat-value">{{ researchModule.powerConsumption.value }}%</span>
</div>
<div class="stat">
<span class="stat-label">Czas pracy:</span>
<span class="stat-value">{{ researchModule.uptime.formattedTime.value }}</span>
</div>
</div>
<div class="module-controls">
<button
@click="researchModule.toggleOnline()"
class="btn"
:class="researchModule.isOnline.value ? 'btn-warning' : 'btn-success'"
>
{{ researchModule.isOnline.value ? 'Wyłącz' : 'Włącz' }}
</button>
</div>
<div class="module-simulations">
<button @click="simulateHeatWave(researchModule)" class="btn btn-sm">Fala ciepła</button>
<button @click="simulateCooling(researchModule)" class="btn btn-sm">Chłodzenie</button>
<button @click="simulatePowerSpike(researchModule)" class="btn btn-sm">Skok mocy</button>
</div>
</div>
<!-- Moduł energetyczny -->
<div class="module-card" :style="{ borderColor: powerModule.status.value.color }">
<div class="module-header">
<h3>{{ powerModule.moduleName.value }}</h3>
<div
class="status-badge"
:style="{ background: powerModule.status.value.color }"
>
{{ powerModule.status.value.level.toUpperCase() }}
</div>
</div>
<div class="module-stats">
<div class="stat">
<span class="stat-label">Temperatura:</span>
<span class="stat-value">{{ powerModule.temperature.value }}°C</span>
</div>
<div class="stat">
<span class="stat-label">Moc:</span>
<span class="stat-value">{{ powerModule.powerConsumption.value }}%</span>
</div>
<div class="stat">
<span class="stat-label">Czas pracy:</span>
<span class="stat-value">{{ powerModule.uptime.formattedTime.value }}</span>
</div>
</div>
<div class="module-controls">
<button
@click="powerModule.toggleOnline()"
class="btn"
:class="powerModule.isOnline.value ? 'btn-warning' : 'btn-success'"
>
{{ powerModule.isOnline.value ? 'Wyłącz' : 'Włącz' }}
</button>
</div>
<div class="module-simulations">
<button @click="simulateHeatWave(powerModule)" class="btn btn-sm">Fala ciepła</button>
<button @click="simulateCooling(powerModule)" class="btn btn-sm">Chłodzenie</button>
<button @click="simulatePowerSpike(powerModule)" class="btn btn-sm">Skok mocy</button>
</div>
</div>
</div>
<div class="info-panel">
<h3>Dobre praktyki dla composables</h3>
<div class="info-grid">
<div class="info-section">
<h4>1. Jedna odpowiedzialność</h4>
<ul>
<li>Każdy composable ma jedną odpowiedzialność</li>
<li>useTimer - tylko zarządzanie timerem</li>
<li>Łatwy w testowaniu i utrzymaniu</li>
</ul>
</div>
<div class="info-section">
<h4>2. Kompozycja composables</h4>
<ul>
<li>Łączenie composables dla złożonej logiki</li>
<li>useModuleStatus używa useTimer</li>
<li>Reużywalność i modularność</li>
</ul>
</div>
<div class="info-section">
<h4>3. Wzorzec opcji</h4>
<ul>
<li>Przyjmowanie opcji z wartościami domyślnymi</li>
<li>useNotifications({ maxNotifications: 5 })</li>
<li>Elastyczność i łatwe dostosowanie</li>
</ul>
</div>
<div class="info-section">
<h4>4. Konwencja nazewnictwa</h4>
<ul>
<li>Zawsze przedrostek "use"</li>
<li>Opisowa nazwa: useModuleStatus</li>
<li>Łatwe do zidentyfikowania</li>
</ul>
</div>
</div>
<div class="code-example">
<code>
// Dobrze: jedna odpowiedzialność
function useTimer() { ... }
// Dobrze: kompozycja
function useModule() {
const timer = useTimer()
return { timer, ... }
}
// Dobrze: opcje z wartościami domyślnymi
function useNotify(options = {}) {
const { maxItems = 10 } = options
...
}
</code>
</div>
</div>
</div>
</template>
<style scoped>
.integration-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: 2.5rem;
color: #00ff88;
text-shadow: 0 0 20px rgba(0, 255, 136, 0.5);
margin: 0;
}
.subtitle {
color: #00b4d8;
font-size: 1.2rem;
margin-top: 0.5rem;
}
.notifications-panel {
background: rgba(0, 180, 216, 0.05);
border: 2px solid #00b4d8;
border-radius: 10px;
padding: 1.5rem;
margin-bottom: 2rem;
}
.notifications-header {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 1rem;
}
.notifications-header h3 {
color: #00b4d8;
margin: 0;
}
.notifications-list {
display: flex;
flex-direction: column;
gap: 0.5rem;
max-height: 300px;
overflow-y: auto;
}
.notification {
display: flex;
align-items: center;
gap: 1rem;
padding: 1rem;
border-radius: 5px;
border-left: 4px solid;
animation: slideIn 0.3s ease;
}
@keyframes slideIn {
from {
transform: translateX(-20px);
opacity: 0;
}
to {
transform: translateX(0);
opacity: 1;
}
}
.notification-success {
background: rgba(0, 255, 136, 0.1);
border-color: #00ff88;
}
.notification-info {
background: rgba(0, 180, 216, 0.1);
border-color: #00b4d8;
}
.notification-warning {
background: rgba(255, 180, 0, 0.1);
border-color: #ffb400;
}
.notification-type {
color: #00b4d8;
font-size: 0.8rem;
font-weight: bold;
min-width: 80px;
}
.notification-message {
flex: 1;
color: #ffffff;
}
.btn-close {
background: rgba(255, 0, 85, 0.3);
color: #ff0055;
border: none;
width: 30px;
height: 30px;
border-radius: 50%;
font-size: 1.5rem;
cursor: pointer;
display: flex;
align-items: center;
justify-content: center;
transition: all 0.3s ease;
}
.btn-close:hover {
background: #ff0055;
color: #ffffff;
}
.modules-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
gap: 2rem;
margin-bottom: 2rem;
}
.module-card {
background: rgba(0, 255, 136, 0.05);
border: 3px solid;
border-radius: 10px;
padding: 1.5rem;
transition: all 0.3s ease;
}
.module-header {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 1.5rem;
}
.module-header h3 {
color: #00ff88;
margin: 0;
}
.status-badge {
padding: 0.5rem 1rem;
border-radius: 20px;
font-size: 0.8rem;
font-weight: bold;
color: #0a0e27;
}
.module-stats {
background: rgba(0, 0, 0, 0.3);
border-radius: 8px;
padding: 1rem;
margin-bottom: 1rem;
}
.stat {
display: flex;
justify-content: space-between;
padding: 0.5rem 0;
border-bottom: 1px solid rgba(255, 255, 255, 0.1);
}
.stat:last-child {
border-bottom: none;
}
.stat-label {
color: #00b4d8;
}
.stat-value {
color: #00ff88;
font-weight: bold;
}
.module-controls {
margin: 1rem 0;
}
.module-simulations {
display: flex;
gap: 0.5rem;
flex-wrap: wrap;
}
.btn {
padding: 0.75rem 1.5rem;
border: none;
border-radius: 5px;
font-weight: bold;
cursor: pointer;
font-family: 'Courier New', monospace;
transition: all 0.3s ease;
width: 100%;
}
.btn-sm {
padding: 0.5rem 1rem;
font-size: 0.85rem;
width: auto;
flex: 1;
background: rgba(0, 180, 216, 0.3);
color: #00b4d8;
}
.btn-success {
background: #00ff88;
color: #0a0e27;
}
.btn-warning {
background: #ffb400;
color: #0a0e27;
}
.btn-danger {
background: #ff0055;
color: #ffffff;
}
.btn:hover {
transform: scale(1.05);
box-shadow: 0 5px 15px rgba(0, 255, 136, 0.3);
}
.info-panel {
background: rgba(0, 255, 136, 0.05);
border: 2px solid #00ff88;
border-radius: 10px;
padding: 2rem;
}
.info-panel h3 {
color: #00ff88;
margin-top: 0;
margin-bottom: 1.5rem;
text-align: center;
}
.info-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
gap: 1.5rem;
margin-bottom: 2rem;
}
.info-section {
background: rgba(0, 180, 216, 0.1);
border: 2px solid #00b4d8;
border-radius: 8px;
padding: 1.5rem;
}
.info-section h4 {
color: #00b4d8;
margin-top: 0;
margin-bottom: 1rem;
}
.info-section ul {
list-style: none;
padding: 0;
margin: 0;
}
.info-section li {
padding: 0.5rem 0;
color: #ffffff;
font-size: 0.9rem;
line-height: 1.6;
}
.code-example {
background: rgba(0, 0, 0, 0.5);
border-left: 4px solid #00ff88;
border-radius: 5px;
padding: 1.5rem;
}
.code-example code {
color: #00ff88;
font-size: 0.9rem;
white-space: pre;
display: block;
}
</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. Co powinien zwracać composable useExperiments?
2. Do czego używamy computed() w composables?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Zbuduj useExperiments z fetchExperiments, addExperiment, deleteExperiment i computed properties.
- Układanie w pionie
Ułóż workflow pracy z composables od stworzenia do użycia:
- Klikanie w kolejności
Ułóż pattern composable zarządzającego listą danych:
- Układanie w poziomie
Ułóż composable przyjmujący parametr:
- Edytor kodu
Zbuduj useLabFilters z search, category, sort i computed filteredItems.
- Układanie w pionie
Ułóż kroki integracji wielu composables w jednym komponencie:
- Układanie w poziomie
Ułóż computed property w composable:
- Klikanie w kolejności
Ułóż pełny cykl życia composable w aplikacji:
- Układanie w pionie
Ułóż architekturę Lab Manager od danych do widoku:
- Klikanie w kolejności
Ułóż script setup integrujący composables:
- Układanie w poziomie
Ułóż ścieżkę importu composable:
- Układanie w pionie
Ułóż kroki inicjalizacji composable który pobiera dane z serwera:
Zadania po tej lekcji
- PytanieComposable useExperiments
- PytanieComputed w composables
- Zadanie z kodemPraktyka: useExperiments
- Ułóż w kolejnościWorkflow composables
- Kliknij w kolejnościPattern composable z CRUD
- Ułóż w kolejnościComposable z parametrem
- Zadanie z kodemPraktyka: useLabFilters
- PytanieKompozycja composables
- Ułóż w kolejnościIntegracja composables w komponencie
- Ułóż w kolejnościComputed w composable
- Kliknij w kolejnościPełny cykl composable
- Ułóż w kolejnościKompozycja w Lab Manager
- Kliknij w kolejnościscript setup z composables
- Ułóż w kolejnościLokalizacja pliku composable
- Ułóż w kolejnościPoprawna inicjalizacja composable z API