Kurs JavaScript i React · Moduł 1: Podstawy React
Virtual DOM i jego zalety
W tej lekcji6
Jedną z najbardziej innowacyjnych cech React jest koncepcja Wirtualnego DOM (Document Object Model). Aby zrozumieć jego znaczenie, musimy najpierw zrozumieć problem, który rozwiązuje.
Problem z tradycyjnym DOM
Wyobraź sobie, że DOM przeglądarki to ogromna mapa gwiezdna, na której każda gwiazda, planeta i stacja kosmiczna musi być precyzyjnie umieszczona. Zmiana na tej mapie ma swój koszt: przeglądarka musi przeliczyć położenie obiektów, na które ta zmiana wpływa.
W tradycyjnym podejściu, gdy użytkownik wykonuje akcję (np. klika przycisk), musisz sam:
- Znaleźć w DOM wszystkie elementy, których dotyczy zmiana
- Zmienić każdy z nich ręcznie - albo, dla wygody, przebudować cały fragment strony (np. przez innerHTML)
Po każdej zmianie przeglądarka przelicza style i układ (layout), a potem przerysowuje (paint) zmienioną część strony. Przy przebudowie całego fragmentu robi to dla wszystkich jego elementów, choć zmienił się tylko jeden.
To jak przeprojektowywanie całego statku kosmicznego, gdy chcesz tylko zmienić kolor jednego przycisku na panelu sterowania!
Jak działa Virtual DOM
React wprowadził rewolucyjne podejście:
- Użytkownik wykonuje akcję
- React tworzy nowy Wirtualny DOM (lekką, javascriptową kopię rzeczywistego DOM)
- React porównuje poprzedni Wirtualny DOM z nowym (algorytm "diffing")
- React aktualizuje tylko te elementy rzeczywistego DOM, które faktycznie się zmieniły
To jak posiadanie holograficznej makiety statku kosmicznego, na której planujesz zmiany i testujesz je, zanim wprowadzisz je do prawdziwego statku. Ten proces jest niewiarygodnie efektywny, szczególnie w złożonych aplikacjach, gdzie wiele elementów może zmieniać się jednocześnie.
Przykład działania Virtual DOM
Rozważmy prosty przykład: mamy listę zadań do wykonania, a użytkownik właśnie oznaczył jedno zadanie jako ukończone.
W tradycyjnym podejściu:
- Albo sam znajdujesz i zmieniasz właściwy element listy - i musisz pamiętać o każdym takim miejscu w kodzie
- Albo budujesz całą listę od nowa (np. przez innerHTML) - prościej, ale przeglądarka przetwarza wtedy wszystkie elementy listy
Z React i Virtual DOM:
- React tworzy nową wersję Virtual DOM z zaktualizowanym stanem zadania
- Porównuje ją z poprzednią wersją
- Odnajduje tylko jeden zmieniony element (zadanie oznaczone jako ukończone)
- Aktualizuje tylko ten konkretny element w rzeczywistym DOM
Szczegóły implementacji Virtual DOM
Virtual DOM działa na kilku poziomach:
- Reprezentacja elementów - Każdy element JSX jest przekształcany w lekki obiekt JavaScript reprezentujący węzeł DOM
- Reconciliation - Proces porównywania dwóch drzew Virtual DOM i obliczania minimalnego zestawu operacji potrzebnych do aktualizacji rzeczywistego DOM
- Batching - React grupuje wiele aktualizacji w jedną sesję, aby zminimalizować liczbę operacji na rzeczywistym DOM
// Ten kod JSX
<div className="task-list">
<Task completed={true} name="Zadanie 1" />
<Task completed={false} name="Zadanie 2" />
</div>
// Jest przekształcany w strukturę podobną do tej (uproszczone)
{
type: 'div',
props: {
className: 'task-list',
children: [
{
type: Task,
props: { completed: true, name: 'Zadanie 1' }
},
{
type: Task,
props: { completed: false, name: 'Zadanie 2' }
}
]
}
}Zalety Virtual DOM
Zalety tego podejścia są ogromne:
- Wydajność - szczególnie w złożonych aplikacjach, gdzie tradycyjne podejście mogłoby powodować zauważalne opóźnienia
- Abstrakcja DOM - deweloperzy mogą skupić się na logice aplikacji, a nie na szczegółach manipulacji DOM
- Przewidywalność - łatwiej śledzić zmiany stanu i debugować problemy
- Łatwość testowania - komponenty można testować w izolacji
- Cross-platform - ponieważ Virtual DOM to zwykły obiekt JavaScript, ta sama koncepcja może być używana na różnych platformach (Web, Mobile z React Native)
Fiber - nowa generacja Virtual DOM
Od wersji React 16, wprowadzono nową implementację algorytmu reconciliation o nazwie Fiber. Ta architektura umożliwia:
- Przerywalne aktualizacje - długie operacje renderowania mogą zostać podzielone na mniejsze części
- Priorytetyzację aktualizacji - niektóre aktualizacje (np. animacje) mogą mieć większy priorytet
- Lepszą obsługę błędów
- Lepsze wsparcie dla Concurrent Mode
Ta ewolucja Virtual DOM pokazuje, jak React nieustannie rozwija swoje kluczowe technologie, aby sprostać wyzwaniom nowoczesnych aplikacji internetowych.
Kod do tej lekcji: App.jsx
import React from 'react';
// Komponent demonstrujący tradycyjny DOM
function TraditionalDOMDemo() {
const [updates, setUpdates] = React.useState(0);
const [isAnimating, setIsAnimating] = React.useState(false);
const simulateTraditionalUpdate = () => {
setIsAnimating(true);
setUpdates(prev => prev + 1);
setTimeout(() => {
setIsAnimating(false);
}, 1000);
};
return (
<div style={{
backgroundColor: '#ffebee',
padding: '20px',
borderRadius: '8px',
border: '2px solid #f44336',
margin: '15px 0'
}}>
<h3 style={{ color: '#c62828', marginBottom: '15px' }}>
Tradycyjny DOM (Powolny)
</h3>
<div style={{
display: 'flex',
alignItems: 'center',
marginBottom: '15px',
gap: '15px'
}}>
<button
onClick={simulateTraditionalUpdate}
disabled={isAnimating}
style={{
padding: '10px 20px',
backgroundColor: isAnimating ? '#ccc' : '#f44336',
color: 'white',
border: 'none',
borderRadius: '4px',
cursor: isAnimating ? 'not-allowed' : 'pointer'
}}
>
{isAnimating ? 'Aktualizuję...' : 'Aktualizuj DOM'}
</button>
<div style={{
padding: '8px 15px',
backgroundColor: 'white',
borderRadius: '4px',
border: '1px solid #ccc'
}}>
Aktualizacji: {updates}
</div>
</div>
<div style={{
backgroundColor: 'white',
padding: '15px',
borderRadius: '4px',
opacity: isAnimating ? 0.5 : 1,
transition: 'opacity 1s'
}}>
<h4>Kroki tradycyjnej aktualizacji:</h4>
<ol style={{ color: '#666' }}>
<li>Znajdź wszystkie elementy do zmiany</li>
<li>Zmień każdy element osobno</li>
<li>Przelicz style i układ (reflow)</li>
<li>Przerysuj zmienioną część strony (repaint)</li>
</ol>
{isAnimating && (
<div style={{
color: '#f44336',
fontStyle: 'italic',
marginTop: '10px'
}}>
⏳ Aktualizowanie... To może zająć chwilę dla dużych stron!
</div>
)}
</div>
</div>
);
}
// Komponent demonstrujący Virtual DOM
function VirtualDOMDemo() {
const [updates, setUpdates] = React.useState(0);
const [isProcessing, setIsProcessing] = React.useState(false);
const [virtualChanges, setVirtualChanges] = React.useState([]);
const simulateVirtualDOMUpdate = () => {
setIsProcessing(true);
setVirtualChanges(['Tworzę Virtual DOM...']);
setTimeout(() => {
setVirtualChanges(['Tworzę Virtual DOM...', 'Porównuję z poprzednią wersją...']);
}, 300);
setTimeout(() => {
setVirtualChanges([
'Tworzę Virtual DOM...',
'Porównuję z poprzednią wersją...',
'Znaleziono 1 zmianę do zaktualizowania'
]);
}, 600);
setTimeout(() => {
setVirtualChanges([
'Tworzę Virtual DOM...',
'Porównuję z poprzednią wersją...',
'Znaleziono 1 zmianę do zaktualizowania',
'Aktualizuję tylko potrzebne elementy'
]);
setUpdates(prev => prev + 1);
setIsProcessing(false);
}, 900);
setTimeout(() => {
setVirtualChanges([]);
}, 2000);
};
return (
<div style={{
backgroundColor: '#e8f5e8',
padding: '20px',
borderRadius: '8px',
border: '2px solid #4caf50',
margin: '15px 0'
}}>
<h3 style={{ color: '#2e7d32', marginBottom: '15px' }}>
Virtual DOM React (Szybki)
</h3>
<div style={{
display: 'flex',
alignItems: 'center',
marginBottom: '15px',
gap: '15px'
}}>
<button
onClick={simulateVirtualDOMUpdate}
disabled={isProcessing}
style={{
padding: '10px 20px',
backgroundColor: isProcessing ? '#ccc' : '#4caf50',
color: 'white',
border: 'none',
borderRadius: '4px',
cursor: isProcessing ? 'not-allowed' : 'pointer'
}}
>
{isProcessing ? 'Przetwarzam...' : 'Aktualizuj Virtual DOM'}
</button>
<div style={{
padding: '8px 15px',
backgroundColor: 'white',
borderRadius: '4px',
border: '1px solid #ccc'
}}>
Aktualizacji: {updates}
</div>
</div>
<div style={{
backgroundColor: 'white',
padding: '15px',
borderRadius: '4px'
}}>
<h4>Proces Virtual DOM:</h4>
<ul style={{ color: '#666', minHeight: '100px' }}>
{virtualChanges.map((change, index) => (
<li key={index} style={{
marginBottom: '5px',
opacity: 0,
animation: 'fadeIn 0.5s forwards',
animationDelay: `${index * 0.2}s`
}}>
{change}
</li>
))}
{!isProcessing && virtualChanges.length === 0 && (
<li style={{ color: '#999', fontStyle: 'italic' }}>
Kliknij przycisk, aby zobaczyć proces Virtual DOM w akcji
</li>
)}
</ul>
</div>
<style>
{`
@keyframes fadeIn {
from { opacity: 0; }
to { opacity: 1; }
}
`}
</style>
</div>
);
}
// Komponent demonstrujący różnice w wydajności
function PerformanceDifference() {
const [itemCount, setItemCount] = React.useState(100);
const [items, setItems] = React.useState([]);
React.useEffect(() => {
const newItems = Array.from({ length: itemCount }, (_, i) => ({
id: i,
name: `Element ${i + 1}`,
value: Math.floor(Math.random() * 100)
}));
setItems(newItems);
}, [itemCount]);
const updateAllItems = () => {
setItems(prevItems =>
prevItems.map(item => ({
...item,
value: Math.floor(Math.random() * 100)
}))
);
};
return (
<div style={{
backgroundColor: '#f3e5f5',
padding: '20px',
borderRadius: '8px',
border: '2px solid #9c27b0',
margin: '15px 0'
}}>
<h3 style={{ color: '#7b1fa2', marginBottom: '15px' }}>
Demonstracja Wydajności Virtual DOM
</h3>
<div style={{
display: 'flex',
gap: '15px',
marginBottom: '15px',
flexWrap: 'wrap',
alignItems: 'center'
}}>
<label style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
Liczba elementów:
<input
type="range"
min="50"
max="1000"
step="50"
value={itemCount}
onChange={(e) => setItemCount(Number(e.target.value))}
style={{ width: '150px' }}
/>
<span style={{ minWidth: '60px' }}>{itemCount}</span>
</label>
<button
onClick={updateAllItems}
style={{
padding: '10px 20px',
backgroundColor: '#9c27b0',
color: 'white',
border: 'none',
borderRadius: '4px',
cursor: 'pointer'
}}
>
Aktualizuj Wszystkie
</button>
</div>
<div style={{
display: 'grid',
gridTemplateColumns: 'repeat(auto-fill, minmax(120px, 1fr))',
gap: '8px',
maxHeight: '200px',
overflow: 'auto',
backgroundColor: 'white',
padding: '15px',
borderRadius: '4px'
}}>
{items.map(item => (
<div
key={item.id}
style={{
padding: '8px',
backgroundColor: `hsl(${item.value * 3.6}, 70%, 90%)`,
borderRadius: '4px',
textAlign: 'center',
fontSize: '12px',
transition: 'background-color 0.3s'
}}
>
<div style={{ fontWeight: 'bold' }}>{item.name}</div>
<div>{item.value}</div>
</div>
))}
</div>
<div style={{
marginTop: '15px',
padding: '10px',
backgroundColor: 'white',
borderRadius: '4px',
fontSize: '14px',
color: '#666'
}}>
<strong>Zauważ:</strong> Nawet przy aktualizacji {itemCount} elementów,
React dzięki Virtual DOM płynnie przetwarza zmiany i aktualizuje tylko
te elementy, które rzeczywiście się zmieniły!
</div>
</div>
);
}
// Komponent z interaktywną wizualizacją procesu
function VirtualDOMVisualization() {
const [step, setStep] = React.useState(0);
const steps = [
{ title: "Stan Początkowy", desc: "Mamy istniejący Virtual DOM" },
{ title: "Zmiana Stanu", desc: "Użytkownik wykonuje akcję (np. klika przycisk)" },
{ title: "Nowy Virtual DOM", desc: "React tworzy nowy Virtual DOM" },
{ title: "Diff Algorithm", desc: "React porównuje stary i nowy Virtual DOM" },
{ title: "Minimalne Zmiany", desc: "React identyfikuje minimalny zestaw zmian" },
{ title: "Aktualizacja DOM", desc: "Tylko potrzebne elementy są aktualizowane" }
];
const nextStep = () => {
setStep(prev => (prev + 1) % steps.length);
};
const resetSteps = () => {
setStep(0);
};
return (
<div style={{
backgroundColor: '#fff3e0',
padding: '20px',
borderRadius: '8px',
border: '2px solid #ff9800',
margin: '15px 0'
}}>
<h3 style={{ color: '#f57c00', marginBottom: '15px' }}>
Krok Po Kroku: Jak Działa Virtual DOM
</h3>
<div style={{
display: 'flex',
gap: '10px',
marginBottom: '20px'
}}>
<button onClick={nextStep} style={{
padding: '10px 20px',
backgroundColor: '#ff9800',
color: 'white',
border: 'none',
borderRadius: '4px',
cursor: 'pointer'
}}>
Następny Krok
</button>
<button onClick={resetSteps} style={{
padding: '10px 20px',
backgroundColor: '#666',
color: 'white',
border: 'none',
borderRadius: '4px',
cursor: 'pointer'
}}>
Reset
</button>
</div>
<div style={{
backgroundColor: 'white',
padding: '20px',
borderRadius: '8px',
minHeight: '120px'
}}>
<div style={{
display: 'flex',
alignItems: 'center',
marginBottom: '15px'
}}>
<div style={{
width: '40px',
height: '40px',
backgroundColor: '#ff9800',
color: 'white',
borderRadius: '50%',
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
fontWeight: 'bold',
marginRight: '15px'
}}>
{step + 1}
</div>
<h4 style={{ margin: 0, color: '#333' }}>
{steps[step].title}
</h4>
</div>
<p style={{ color: '#666', fontSize: '16px', lineHeight: '1.5' }}>
{steps[step].desc}
</p>
<div style={{
marginTop: '15px',
display: 'flex',
gap: '5px'
}}>
{steps.map((_, index) => (
<div
key={index}
style={{
width: '12px',
height: '12px',
borderRadius: '50%',
backgroundColor: index <= step ? '#ff9800' : '#ddd',
transition: 'background-color 0.3s'
}}
/>
))}
</div>
</div>
</div>
);
}
export default function App() {
return (
<div style={{
fontFamily: 'Arial, sans-serif',
maxWidth: '900px',
margin: '0 auto',
padding: '20px'
}}>
<header style={{
textAlign: 'center',
marginBottom: '30px',
padding: '25px',
background: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
color: 'white',
borderRadius: '12px'
}}>
<h1 style={{ margin: '0 0 10px 0', fontSize: '2.2rem' }}>
Virtual DOM i jego Zalety
</h1>
<p style={{ margin: 0, fontSize: '1rem', opacity: 0.9 }}>
Odkryj sekret wydajności React i zrozum, dlaczego Virtual DOM
to prawdziwa rewolucja w świecie front-endu
</p>
</header>
<section style={{ marginBottom: '30px' }}>
<h2 style={{
color: '#333',
borderBottom: '2px solid #667eea',
paddingBottom: '10px',
marginBottom: '20px'
}}>
Tradycyjny DOM vs Virtual DOM
</h2>
<TraditionalDOMDemo />
<VirtualDOMDemo />
</section>
<VirtualDOMVisualization />
<PerformanceDifference />
<div style={{
backgroundColor: '#e3f2fd',
padding: '25px',
borderRadius: '12px',
marginTop: '30px'
}}>
<h3 style={{ color: '#1976d2', textAlign: 'center', marginBottom: '20px' }}>
Kluczowe Zalety Virtual DOM
</h3>
<div style={{
display: 'grid',
gridTemplateColumns: 'repeat(auto-fit, minmax(250px, 1fr))',
gap: '20px'
}}>
<div style={{ textAlign: 'center' }}>
<div style={{ fontSize: '40px', marginBottom: '10px' }}>↯</div>
<h4 style={{ color: '#1976d2' }}>Wydajność</h4>
<p style={{ margin: 0, color: '#666' }}>
Minimalne aktualizacje DOM = szybsze aplikacje
</p>
</div>
<div style={{ textAlign: 'center' }}>
<div style={{ fontSize: '40px', marginBottom: '10px' }}>◆</div>
<h4 style={{ color: '#1976d2' }}>Przewidywalność</h4>
<p style={{ margin: 0, color: '#666' }}>
Łatwiejsze śledzenie zmian i debugowanie
</p>
</div>
<div style={{ textAlign: 'center' }}>
<div style={{ fontSize: '40px', marginBottom: '10px' }}>◆</div>
<h4 style={{ color: '#1976d2' }}>Testowalność</h4>
<p style={{ margin: 0, color: '#666' }}>
Komponenty można testować w izolacji
</p>
</div>
<div style={{ textAlign: 'center' }}>
<div style={{ fontSize: '40px', marginBottom: '10px' }}>●</div>
<h4 style={{ color: '#1976d2' }}>Cross-platform</h4>
<p style={{ margin: 0, color: '#666' }}>
Ta sama koncepcja działa wszędzie
</p>
</div>
</div>
</div>
</div>
);
}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 to jest Virtual DOM w React?
2. Co to są komponenty w React?
3. Jaka jest główna zaleta Virtual DOM w React?
4. Na czym polega algorytm diffing (reconciliation) w React?
Zadania praktyczne w grze
- Klikanie w kolejności
Ułóż proces działania Virtual DOM: