Kurs Next.js · Moduł 5: Strategie renderowania
Skelety ładowania i wskaźniki postępu
W tej lekcji12
W poprzednim module omówiliśmy, jak używać React Suspense i streamowania danych, aby poprawić wydajność ładowania i responsywność interfejsu użytkownika. Jednak samo oczekiwanie na ładowanie danych bez odpowiedniego informowania użytkownika o tym, co się dzieje, może powodować frustrację i wrażenie, że aplikacja nie działa. W tym module skupimy się na tworzeniu zaawansowanych szkieletów ładowania i wskaźników postępu, które uzupełniają strategię streamingu danych i zapewniają doskonałe doświadczenie użytkownika.
Dlaczego szkielety ładowania są ważne?
Szkielety ładowania (loading skeletons) i wskaźniki postępu to kluczowe elementy nowoczesnych aplikacji internetowych z kilku powodów:
- Redukują postrzeganą latencję - nawet jeśli faktyczny czas ładowania się nie zmienia, użytkownicy postrzegają go jako krótszy, gdy widzą, że coś się dzieje
- Zapobiegają przeskokom układu (CLS) - utrzymują strukturę strony, zmniejszając przeskoki podczas ładowania
- Komunikują stan aplikacji - informują użytkownika, że dane są ładowane, zamiast pozostawiać go w niepewności
- Poprawiają metryki Core Web Vitals - mniejszy CLS i lepszy LCP (Largest Contentful Paint) przekładają się na lepsze wskaźniki wydajności
Rodzaje wskaźników stanu ładowania
Istnieje kilka podejść do informowania użytkownika o stanie ładowania:
- Szkielety ładowania (Skeleton UI) - uproszczone reprezentacje graficzne treści, które będą wyświetlane
- Wskaźniki postępu - wizualne reprezentacje postępu ładowania (paski, kółka)
- Indeterminate loaders - animowane wskaźniki (np. kręcące się koła), które nie pokazują dokładnego postępu
- Opóźnione renderowanie - pokazywanie wskaźników ładowania tylko po określonym czasie, aby uniknąć migotania
- Animacje przejścia - płynne przejścia między stanami ładowania a gotową zawartością
Implementacja szkieletów ładowania w Next.js
1. Podstawowe komponenty szkieletowe
Zacznijmy od utworzenia podstawowych komponentów szkieletowych, które możemy używać jako elementy zastępcze podczas ładowania:
// components/ui/skeleton.tsx
import { cn } from '@/lib/utils';
interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {}
export function Skeleton({ className, ...props }: SkeletonProps) {
return (
<div
className={cn(
"animate-pulse rounded-md bg-gray-200 dark:bg-gray-800",
className
)}
{...props}
/>
);
}Ten prosty komponent tworzy pulsujący element, który można dostosowywać za pomocą klas i właściwości. Możemy teraz używać go do tworzenia różnych typów szkieletów ładowania.
2. Zaawansowane szkielety dla poszczególnych typów zawartości
Możemy tworzyć bardziej zaawansowane szkielety dla konkretnych typów zawartości, jak karty produktów, tabele czy listy:
// components/skeletons/product-card-skeleton.tsx
import { Skeleton } from "@/components/ui/skeleton";
export function ProductCardSkeleton() {
return (
<div className="space-y-4 rounded-lg border p-4">
{/* Szkielet obrazu produktu */}
<Skeleton className="h-[200px] w-full rounded-lg" />
{/* Szkielet nazwy produktu */}
<Skeleton className="h-8 w-3/4" />
{/* Szkielet ceny i oceny */}
<div className="flex justify-between">
<Skeleton className="h-6 w-1/4" />
<Skeleton className="h-6 w-1/4" />
</div>
{/* Szkielet przycisku */}
<Skeleton className="h-10 w-full" />
</div>
);
}// components/skeletons/table-skeleton.tsx
import { Skeleton } from "@/components/ui/skeleton";
interface TableSkeletonProps {
rows?: number;
columns?: number;
}
export function TableSkeleton({ rows = 5, columns = 4 }: TableSkeletonProps) {
return (
<div className="w-full space-y-3 rounded-lg border p-4">
{/* Nagłówek tabeli */}
<div className="flex gap-3 pb-2">
{Array.from({ length: columns }).map((_, i) => (
<Skeleton key={`header-${i}`} className="h-10 flex-1" />
))}
</div>
{/* Wiersze tabeli */}
{Array.from({ length: rows }).map((_, rowIndex) => (
<div key={`row-${rowIndex}`} className="flex gap-3">
{Array.from({ length: columns }).map((_, colIndex) => (
<Skeleton
key={`cell-${rowIndex}-${colIndex}`}
className="h-12 flex-1"
/>
))}
</div>
))}
</div>
);
}3. Używanie szkieletów z React Suspense
Teraz możemy połączyć nasze szkielety ładowania z React Suspense, aby używać ich jako fallbacków podczas streamowania danych:
// app/products/page.tsx
import { Suspense } from "react";
import { ProductGrid } from "./product-grid";
import { ProductFilters } from "./product-filters";
import { ProductGridSkeleton } from "@/components/skeletons/product-grid-skeleton";
import { ProductFiltersSkeleton } from "@/components/skeletons/product-filters-skeleton";
export default function ProductsPage() {
return (
<div className="container mx-auto py-10">
<h1 className="mb-8 text-3xl font-bold">Nasze produkty</h1>
<div className="grid grid-cols-4 gap-6">
<div className="col-span-1">
<Suspense fallback={<ProductFiltersSkeleton />}>
<ProductFilters />
</Suspense>
</div>
<div className="col-span-3">
<Suspense fallback={<ProductGridSkeleton />}>
<ProductGrid />
</Suspense>
</div>
</div>
</div>
);
}W tym przykładzie tworzymy szkielety dla filtrów produktów i siatki produktów, dzięki czemu podczas ładowania użytkownik widzi odpowiednią strukturę strony.
Wskaźniki postępu w Next.js
Oprócz szkieletów ładowania, możemy również używać wskaźników postępu, aby informować użytkownika o stanie operacji, szczególnie tych, które zajmują więcej czasu.
1. Prosty wskaźnik postępu
// components/ui/progress.tsx
"use client";
import * as React from "react";
import * as ProgressPrimitive from "@radix-ui/react-progress";
import { cn } from "@/lib/utils";
interface ProgressProps extends React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root> {
indicatorClassName?: string;
}
const Progress = React.forwardRef<
React.ElementRef<typeof ProgressPrimitive.Root>,
ProgressProps
>(({ className, value, indicatorClassName, ...props }, ref) => (
<ProgressPrimitive.Root
ref={ref}
className={cn(
"relative h-2 w-full overflow-hidden rounded-full bg-gray-100 dark:bg-gray-800",
className
)}
{...props}
>
<ProgressPrimitive.Indicator
className={cn(
"h-full w-full flex-1 bg-blue-600 transition-all dark:bg-blue-400",
indicatorClassName
)}
style={{ transform: `translateX(-${100 - (value || 0)}%)` }}
/>
</ProgressPrimitive.Root>
));
Progress.displayName = ProgressPrimitive.Root.displayName;
export { Progress };2. Nieokreślony wskaźnik ładowania (Spinner)
// components/ui/spinner.tsx
import { cn } from "@/lib/utils";
interface SpinnerProps extends React.HTMLAttributes<HTMLDivElement> {
size?: "sm" | "md" | "lg";
variant?: "primary" | "secondary";
}
export function Spinner({
className,
size = "md",
variant = "primary",
...props
}: SpinnerProps) {
const sizeClasses = {
sm: "h-4 w-4 border-2",
md: "h-6 w-6 border-2",
lg: "h-10 w-10 border-3",
};
const variantClasses = {
primary: "border-blue-600 border-t-transparent",
secondary: "border-gray-600 border-t-transparent",
};
return (
<div
className={cn(
"inline-block animate-spin rounded-full",
sizeClasses[size],
variantClasses[variant],
className
)}
role="status"
aria-label="loading"
{...props}
>
<span className="sr-only">Ładowanie...</span>
</div>
);
}Wskaźniki postępu na poziomie całej aplikacji
W Next.js możemy również implementować wskaźniki postępu na poziomie całej aplikacji, które informują użytkownika o stanie nawigacji między stronami.
1. Globalny wskaźnik postępu przy przejściach stron
// components/global-progress.tsx
"use client";
import { useEffect, useState } from "react";
import { usePathname, useSearchParams } from "next/navigation";
import NProgress from "nprogress";
import "nprogress/nprogress.css";
export function GlobalProgress() {
const pathname = usePathname();
const searchParams = useSearchParams();
const [isNavigating, setIsNavigating] = useState(false);
useEffect(() => {
// Konfiguracja NProgress
NProgress.configure({ showSpinner: false });
// Obsługa rozpoczęcia nawigacji
function onRouteChangeStart() {
setIsNavigating(true);
NProgress.start();
}
// Obsługa zakończenia nawigacji
function onRouteChangeComplete() {
setIsNavigating(false);
NProgress.done();
}
// Dodanie nasłuchiwaczy zdarzeń
window.addEventListener("beforeunload", onRouteChangeStart);
// Usunięcie nasłuchiwaczy zdarzeń po odmontowaniu komponentu
return () => {
window.removeEventListener("beforeunload", onRouteChangeStart);
};
}, []);
// Reagowanie na zmiany ścieżki lub parametrów wyszukiwania
useEffect(() => {
if (isNavigating) {
NProgress.done();
setIsNavigating(false);
}
}, [pathname, searchParams, isNavigating]);
return null; // Ten komponent nie renderuje niczego, tylko zarządza NProgress
}Następnie możemy dodać ten komponent do naszego layout.tsx:
// app/layout.tsx
import { GlobalProgress } from "@/components/global-progress";
export default function RootLayout({ children }) {
return (
<html lang="pl">
<body>
<GlobalProgress />
{children}
</body>
</html>
);
}Zaawansowane techniki zarządzania stanami ładowania
1. Opóźnione renderowanie wskaźników ładowania
W niektórych przypadkach ładowanie danych jest tak szybkie, że pokazywanie wskaźnika ładowania powoduje niepotrzebne migotanie interfejsu. Możemy rozwiązać ten problem poprzez opóźnienie renderowania wskaźnika ładowania:
// hooks/use-delayed-loading.tsx
import { useState, useEffect } from "react";
export function useDelayedLoading(loading: boolean, delay = 300) {
const [showLoading, setShowLoading] = useState(false);
useEffect(() => {
if (loading) {
const timer = setTimeout(() => {
setShowLoading(true);
}, delay);
return () => clearTimeout(timer);
} else {
setShowLoading(false);
}
}, [loading, delay]);
return showLoading && loading;
}Teraz możemy użyć tego hooka w naszych komponentach:
// components/delayed-loading.tsx
"use client";
import { useDelayedLoading } from "@/hooks/use-delayed-loading";
interface DelayedLoadingProps {
loading: boolean;
delay?: number;
fallback: React.ReactNode;
children: React.ReactNode;
}
export function DelayedLoading({
loading,
delay = 300,
fallback,
children
}: DelayedLoadingProps) {
const showLoading = useDelayedLoading(loading, delay);
return showLoading ? fallback : children;
}2. Custom Suspense z opóźnieniem
Możemy również stworzyć własny komponent oparty na Suspense, który wprowadza opóźnienie:
// components/delayed-suspense.tsx
"use client";
import { Suspense, useState, useEffect } from "react";
interface DelayedSuspenseProps {
fallback: React.ReactNode;
children: React.ReactNode;
delay?: number;
}
export function DelayedSuspense({
fallback,
children,
delay = 300
}: DelayedSuspenseProps) {
const [showFallback, setShowFallback] = useState(false);
useEffect(() => {
const timer = setTimeout(() => {
setShowFallback(true);
}, delay);
return () => clearTimeout(timer);
}, [delay]);
return (
<Suspense fallback={showFallback ? fallback : null}>
{children}
</Suspense>
);
}Zarządzanie Cumulative Layout Shift (CLS)
Przeskoki układu (CLS) to jedna z kluczowych metryk Core Web Vitals. Dobrze zaprojektowane szkielety ładowania mogą pomóc w minimalizacji przeskoków układu, zachowując wymiary i proporcje elementów.
1. Zachowanie wymiarów
// components/skeletons/image-skeleton.tsx
import { Skeleton } from "@/components/ui/skeleton";
interface ImageSkeletonProps {
width: number;
height: number;
aspectRatio?: number;
}
export function ImageSkeleton({ width, height, aspectRatio }: ImageSkeletonProps) {
return (
<div
className="overflow-hidden rounded-lg"
style={{
width: width ? `${width}px` : '100%',
height: height ? `${height}px` : '100%',
aspectRatio: aspectRatio ? `${aspectRatio}` : undefined,
}}
>
<Skeleton className="h-full w-full" />
</div>
);
}2. Ładowanie obrazów z zachowaniem miejsca
// components/ui/image.tsx
"use client";
import { useState } from "react";
import Image, { ImageProps } from "next/image";
import { Skeleton } from "@/components/ui/skeleton";
interface OptimizedImageProps extends Omit<ImageProps, "onLoad" | "onError"> {
fallbackClassName?: string;
}
export function OptimizedImage({
fallbackClassName,
className,
alt,
...props
}: OptimizedImageProps) {
const [isLoading, setIsLoading] = useState(true);
return (
<div className="relative">
{isLoading && (
<Skeleton
className={fallbackClassName || className}
style={{
position: "absolute",
top: 0,
left: 0,
right: 0,
bottom: 0,
}}
/>
)}
<Image
className={className}
alt={alt}
onLoad={() => setIsLoading(false)}
{...props}
/>
</div>
);
}Wskaźniki stanu wysyłania formularzy
Oprócz wskaźników ładowania dla danych przychodzących, warto również pokazywać stan operacji wysyłania danych.
1. Przycisk z wskaźnikiem ładowania
// components/ui/loading-button.tsx
import { ButtonHTMLAttributes } from "react";
import { Button } from "@/components/ui/button";
import { Spinner } from "@/components/ui/spinner";
import { cn } from "@/lib/utils";
interface LoadingButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
loading?: boolean;
variant?: "default" | "outline" | "ghost" | "link";
size?: "default" | "sm" | "lg";
spinnerClassName?: string;
}
export function LoadingButton({
children,
loading,
className,
spinnerClassName,
disabled,
...props
}: LoadingButtonProps) {
return (
<Button
className={cn("relative", className)}
disabled={disabled || loading}
{...props}
>
{loading && (
<span className="absolute left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2">
<Spinner size="sm" className={spinnerClassName} />
</span>
)}
<span className={cn(loading ? "invisible" : "")}>{children}</span>
</Button>
);
}2. Formularz z wskaźnikiem stanu
// components/submit-form.tsx
"use client";
import { useState } from "react";
import { useRouter } from "next/navigation";
import { LoadingButton } from "@/components/ui/loading-button";
export function ContactForm() {
const [loading, setLoading] = useState(false);
const [success, setSuccess] = useState(false);
const [error, setError] = useState<string | null>(null);
const router = useRouter();
async function handleSubmit(event: React.FormEvent<HTMLFormElement>) {
event.preventDefault();
setLoading(true);
setError(null);
try {
const formData = new FormData(event.currentTarget);
const response = await fetch('/api/contact', {
method: 'POST',
body: formData,
});
if (!response.ok) {
throw new Error('Wystąpił problem przy wysyłaniu wiadomości');
}
setSuccess(true);
event.currentTarget.reset();
// Przekierowanie po udanym wysłaniu
setTimeout(() => {
router.push('/contact/thank-you');
}, 1500);
} catch (err) {
setError(err instanceof Error ? err.message : 'Wystąpił nieznany błąd');
} finally {
setLoading(false);
}
}
return (
<form onSubmit={handleSubmit} className="space-y-6">
{/* Pola formularza */}
<div className="space-y-4">
<input
type="text"
name="name"
required
className="w-full rounded-md border p-3"
disabled={loading}
/>
<input
type="email"
name="email"
required
className="w-full rounded-md border p-3"
disabled={loading}
/>
<textarea
name="message"
required
className="h-32 w-full rounded-md border p-3"
disabled={loading}
/>
</div>
{/* Stan formularza */}
{error && (
<div className="rounded-md bg-red-50 p-4 text-red-600">
{error}
</div>
)}
{success && (
<div className="rounded-md bg-green-50 p-4 text-green-600">
Wiadomość została wysłana pomyślnie!
</div>
)}
{/* Przycisk wysyłania */}
<LoadingButton
type="submit"
loading={loading}
className="w-full"
>
Wyślij wiadomość
</LoadingButton>
</form>
);
}Wskaźniki postępu dla długotrwałych operacji
Dla operacji, które trwają dłużej, warto pokazywać wskaźniki postępu, które informują użytkownika o aktualnym stanie i pozostałym czasie.
1. Wskaźnik postępu z procentami
// components/ui/percent-progress.tsx
"use client";
import { Progress } from "@/components/ui/progress";
interface PercentProgressProps {
value: number;
max: number;
label?: string;
showPercent?: boolean;
className?: string;
}
export function PercentProgress({
value,
max,
label,
showPercent = true,
className
}: PercentProgressProps) {
const percent = Math.min(Math.round((value / max) * 100), 100);
return (
<div className={className}>
{label && (
<div className="mb-2 flex justify-between">
<span>{label}</span>
{showPercent && <span>{percent}%</span>}
</div>
)}
<Progress value={percent} />
</div>
);
}2. Wskaźnik postępu dla przesyłania plików
// components/file-upload-progress.tsx
"use client";
import { useState } from "react";
import { PercentProgress } from "@/components/ui/percent-progress";
interface FileUploadProgressProps {
onUploadComplete: (url: string) => void;
accept?: string;
maxSizeMB?: number;
}
export function FileUploadProgress({
onUploadComplete,
accept = "image/*",
maxSizeMB = 5
}: FileUploadProgressProps) {
const [progress, setProgress] = useState(0);
const [uploading, setUploading] = useState(false);
const [error, setError] = useState<string | null>(null);
async function handleUpload(event: React.ChangeEvent<HTMLInputElement>) {
const file = event.target.files?.[0];
if (!file) return;
// Sprawdzenie rozmiaru pliku
if (file.size > maxSizeMB * 1024 * 1024) {
setError(`Plik jest zbyt duży. Maksymalny rozmiar to ${maxSizeMB}MB`);
return;
}
setUploading(true);
setError(null);
setProgress(0);
try {
const formData = new FormData();
formData.append('file', file);
const xhr = new XMLHttpRequest();
// Nasłuchiwanie postępu przesyłania
xhr.upload.addEventListener('progress', (event) => {
if (event.lengthComputable) {
const percentComplete = (event.loaded / event.total) * 100;
setProgress(percentComplete);
}
});
// Obsługa zakończenia przesyłania
xhr.addEventListener('load', () => {
if (xhr.status === 200) {
const response = JSON.parse(xhr.responseText);
onUploadComplete(response.url);
} else {
setError('Wystąpił błąd podczas przesyłania pliku');
}
setUploading(false);
});
// Obsługa błędów
xhr.addEventListener('error', () => {
setError('Wystąpił błąd sieci podczas przesyłania pliku');
setUploading(false);
});
// Wysyłka pliku
xhr.open('POST', '/api/upload');
xhr.send(formData);
} catch (err) {
setError('Wystąpił nieoczekiwany błąd');
setUploading(false);
}
}
return (
<div className="space-y-4">
<label className="block">
<span className="mb-1 block font-medium">Wybierz plik:</span>
<input
type="file"
accept={accept}
onChange={handleUpload}
disabled={uploading}
className="w-full cursor-pointer rounded-md border p-2 file:mr-4 file:rounded file:border-0 file:bg-blue-50 file:px-4 file:py-2 file:text-sm file:font-medium file:text-blue-600 hover:file:bg-blue-100"
/>
</label>
{uploading && (
<PercentProgress
value={progress}
max={100}
label="Przesyłanie pliku"
showPercent
/>
)}
{error && (
<div className="rounded-md bg-red-50 p-3 text-sm text-red-600">
{error}
</div>
)}
</div>
);
}Integracja z React Suspense i Server Components
W Next.js możemy łączyć nasze szkielety ładowania i wskaźniki postępu z React Suspense i Server Components, aby stworzyć płynne doświadczenie użytkownika.
1. Dynamiczna strona produktów z różnymi wskaźnikami ładowania
// app/products/page.tsx
import { Suspense } from "react";
import { ProductHeader } from "./product-header";
import { ProductGrid } from "./product-grid";
import { ProductFilters } from "./product-filters";
import { ProductSearch } from "./product-search";
import { ProductGridSkeleton } from "@/components/skeletons/product-grid-skeleton";
import { ProductFiltersSkeleton } from "@/components/skeletons/product-filters-skeleton";
import { ProductHeaderSkeleton } from "@/components/skeletons/product-header-skeleton";
import { DelayedSuspense } from "@/components/delayed-suspense";
export default async function ProductsPage({
searchParams
}: {
searchParams: Promise<{ [key: string]: string | string[] | undefined }>
}) {
return (
<div className="container mx-auto py-10">
{/* Priorytet 1: Nagłówek strony - mała latencja */}
<Suspense fallback={<ProductHeaderSkeleton />}>
<ProductHeader />
</Suspense>
{/* Priorytet 2: Wyszukiwarka - małe opóźnienie */}
<div className="mb-6">
<ProductSearch initialQuery={(await searchParams).q as string} />
</div>
<div className="grid grid-cols-4 gap-6">
{/* Priorytet 3: Filtry - opóźnione renderowanie */}
<div className="col-span-1">
<DelayedSuspense
fallback={<ProductFiltersSkeleton />}
delay={300}
>
<ProductFilters
initialCategory={(await searchParams).category as string}
initialPriceRange={{
min: (await searchParams).minPrice as string,
max: (await searchParams).maxPrice as string,
}}
/>
</DelayedSuspense>
</div>
{/* Priorytet 4: Siatka produktów - z pełnym szkieletem */}
<div className="col-span-3">
<Suspense fallback={<ProductGridSkeleton items={12} />}>
<ProductGrid
category={(await searchParams).category as string}
query={(await searchParams).q as string}
sort={(await searchParams).sort as string}
minPrice={(await searchParams).minPrice as string}
maxPrice={(await searchParams).maxPrice as string}
/>
</Suspense>
</div>
</div>
</div>
);
}2. Implementacja komponentów produktów
// app/products/product-grid.tsx
import { ProductCard } from "@/components/product-card";
interface ProductGridProps {
category?: string;
query?: string;
sort?: string;
minPrice?: string;
maxPrice?: string;
}
async function getProducts(params: ProductGridProps) {
// Konwersja parametrów
const minPrice = (await params).minPrice ? parseInt((await params).minPrice) : undefined;
const maxPrice = (await params).maxPrice ? parseInt((await params).maxPrice) : undefined;
// Symulacja opóźnienia sieci dla demonstracji szkieletów ładowania
await new Promise(resolve => setTimeout(resolve, 1500));
// Prawdziwa implementacja pobierałaby dane z API lub bazy danych
const response = await fetch('https://api.example.com/products', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
category: (await params).category,
query: (await params).query,
sort: (await params).sort,
filters: { price: { min: minPrice, max: maxPrice } }
}),
// W rzeczywistej implementacji możesz użyć cache, revalidate itp.
cache: 'no-store'
});
if (!response.ok) {
throw new Error('Problem z pobieraniem produktów');
}
return response.json();
}
export async function ProductGrid(props: ProductGridProps) {
const products = await getProducts(props);
if (products.length === 0) {
return (
<div className="py-10 text-center">
<h3 className="text-xl font-medium">Nie znaleziono produktów</h3>
<p className="mt-2 text-gray-500">
Spróbuj zmienić kryteria wyszukiwania lub filtry
</p>
</div>
);
}
return (
<div className="grid grid-cols-3 gap-6">
{products.map(product => (
<ProductCard key={product.id} product={product} />
))}
</div>
);
}Wskaźniki stanu ładowania w komponentach klienta
W komponentach klienta używamy innych metod do wyświetlania wskaźników stanu ładowania, ponieważ nie możemy użyć React Suspense dla asynchronicznego pobierania danych w tych komponentach.
1. Hook useAsyncData dla wskaźników ładowania
// hooks/use-async-data.ts
import { useState, useEffect } from "react";
type AsyncStatus = "idle" | "loading" | "success" | "error";
interface UseAsyncDataResult<T> {
data: T | null;
status: AsyncStatus;
error: Error | null;
isLoading: boolean;
isSuccess: boolean;
isError: boolean;
reload: () => void;
}
export function useAsyncData<T>(
fetchFn: () => Promise<T>,
dependencies: any[] = []
): UseAsyncDataResult<T> {
const [data, setData] = useState<T | null>(null);
const [status, setStatus] = useState<AsyncStatus>("idle");
const [error, setError] = useState<Error | null>(null);
const [reloadCounter, setReloadCounter] = useState(0);
function reload() {
setReloadCounter(prev => prev + 1);
}
useEffect(() => {
let isMounted = true;
async function loadData() {
setStatus("loading");
setError(null);
try {
const result = await fetchFn();
if (isMounted) {
setData(result);
setStatus("success");
}
} catch (e) {
if (isMounted) {
setError(e instanceof Error ? e : new Error(String(e)));
setStatus("error");
}
}
}
loadData();
return () => {
isMounted = false;
};
}, [...dependencies, reloadCounter]);
return {
data,
status,
error,
isLoading: status === "loading",
isSuccess: status === "success",
isError: status === "error",
reload,
};
}2. Wykorzystanie hooka w komponencie klienta
// components/user-dashboard.tsx
"use client";
import { useAsyncData } from "@/hooks/use-async-data";
import { Spinner } from "@/components/ui/spinner";
import { ProductCardSkeleton } from "@/components/skeletons/product-card-skeleton";
interface UserDashboardProps {
userId: string;
}
async function fetchUserDashboardData(userId: string) {
const response = await fetch(`/api/users/${userId}/dashboard`);
if (!response.ok) {
throw new Error('Problem z pobieraniem danych dashboardu');
}
return response.json();
}
export function UserDashboard({ userId }: UserDashboardProps) {
const {
data,
isLoading,
isError,
error,
reload
} = useAsyncData(() => fetchUserDashboardData(userId), [userId]);
if (isLoading) {
return (
<div className="space-y-4">
<div className="flex items-center justify-between">
<h2 className="text-2xl font-bold">Twój dashboard</h2>
<div>
<Spinner size="md" />
</div>
</div>
<div className="grid grid-cols-3 gap-4">
{Array.from({ length: 6 }).map((_, i) => (
<ProductCardSkeleton key={i} />
))}
</div>
</div>
);
}
if (isError) {
return (
<div className="rounded-lg bg-red-50 p-6 text-center">
<h3 className="text-lg font-medium text-red-800">Wystąpił błąd</h3>
<p className="mt-2 text-red-600">{error?.message}</p>
<button
onClick={reload}
className="mt-4 rounded-md bg-red-100 px-4 py-2 text-red-800 hover:bg-red-200"
>
Spróbuj ponownie
</button>
</div>
);
}
if (!data) {
return null;
}
return (
<div className="space-y-6">
<div className="flex items-center justify-between">
<h2 className="text-2xl font-bold">Witaj, {data.user.name}</h2>
<button
onClick={reload}
className="rounded-md bg-gray-100 p-2 hover:bg-gray-200"
aria-label="Odśwież dane"
>
<RefreshIcon className="h-5 w-5" />
</button>
</div>
<div className="grid grid-cols-3 gap-4">
{data.recentlyViewed.map(product => (
<ProductCard key={product.id} product={product} />
))}
</div>
{/* Inne sekcje dashboardu */}
</div>
);
}
// Komponent ikony
function RefreshIcon({ className }: { className?: string }) {
return (
<svg
xmlns="http://www.w3.org/2000/svg"
viewBox="0 0 24 24"
fill="none"
stroke="currentColor"
strokeWidth="2"
strokeLinecap="round"
strokeLinejoin="round"
className={className}
>
<path d="M21 2v6h-6" />
<path d="M3 12a9 9 0 0 1 15-6.7L21 8" />
<path d="M3 22v-6h6" />
<path d="M21 12a9 9 0 0 1-15 6.7L3 16" />
</svg>
);
}Podsumowanie i najlepsze praktyki
Oto kluczowe zasady dotyczące tworzenia efektywnych szkieletów ładowania i wskaźników postępu w Next.js:
Dopasowanie do treści - szkielety ładowania powinny odzwierciedlać kształt i proporcje rzeczywistej zawartości
Strategie wyświetlania:
- Dla szybkich operacji (< 300ms) - rozważ brak wskaźnika, aby uniknąć migotania
- Dla średnich operacji (300ms - 1s) - użyj szkieletów lub spinnerów
- Dla długich operacji (> 1s) - używaj wskaźników postępu z rzeczywistym postępem (jeśli to możliwe)
Priorytyzacja zawartości - pokazuj najpierw krytyczne elementy UI:
- Nagłówek i nawigacja
- Główna zawartość strony
- Pomocnicze elementy (filtry, boczne panele) na końcu
Minimalizacja CLS - zawsze definiuj wymiary i proporcje dla szkieletów ładowania
Dostępność - pamiętaj o dostępności wskaźników ładowania:
- Używaj odpowiednich atrybutów ARIA (aria-busy, aria-label)
- Zapewniaj tekstowe alternatywy dla wskaźników wizualnych
- Unikaj migających animacji, które mogą być problematyczne dla osób z epilepsją
Optymalizacja dla urządzeń mobilnych - dostosuj wskaźniki ładowania do różnych rozmiarów ekranów i używaj odpowiednich szkieletów dla układów mobilnych
Spójność wizualna - utrzymuj spójny wygląd szkieletów ładowania z resztą interfejsu użytkownika (kolory, zaokrąglenia, odstępy)
W czasach, gdy użytkownicy oczekują natychmiastowej reakcji, dobrze zaprojektowane stany ładowania są kluczowym elementem doświadczenia użytkownika. Dzięki technikom opisanym w tym module możesz stworzyć aplikacje, które wydają się działać szybciej i zapewniają płynniejsze doświadczenie, nawet gdy dane ładują się w tle.
W następnym module omówimy częściowe prerenderowanie, które jest kolejnym krokiem w optymalizacji wydajności aplikacji Next.js i pozwala na jeszcze lepsze doświadczenie użytkownika.
Kod do tej lekcji: App.tsx
import React, { useState, useEffect } from 'react';
// Skeleton components i loading states w Next.js
function SkeletonLine({ width = '100%' }: { width?: string }) {
return (
<div style={{
height: 14, background: 'linear-gradient(90deg, #1a2744 25%, #243b5e 50%, #1a2744 75%)',
backgroundSize: '200% 100%', borderRadius: 4, width,
animation: 'shimmer 1.5s ease-in-out infinite',
}} />
);
}
function SkeletonCard() {
return (
<div style={{ background: '#0d1117', borderRadius: 8, padding: 16, border: '1px solid #333' }}>
<div style={{ height: 120, background: '#1a2744', borderRadius: 6, marginBottom: 12 }} />
<SkeletonLine width="70%" />
<div style={{ height: 8 }} />
<SkeletonLine width="90%" />
<div style={{ height: 8 }} />
<SkeletonLine width="50%" />
</div>
);
}
// Prawdziwa karta produktu
function ProductCard({ name, price, desc }: { name: string; price: string; desc: string }) {
return (
<div style={{ background: '#1a2744', borderRadius: 8, padding: 16, border: '1px solid #64ffda' }}>
<div style={{
height: 120, background: 'linear-gradient(135deg, #0d47a1, #1a237e)',
borderRadius: 6, marginBottom: 12, display: 'flex', alignItems: 'center',
justifyContent: 'center', fontSize: 32
}}>
{name === 'Quantum Shield' ? '◆' : name === 'Neural Link' ? '◆' : '↯'}
</div>
<h3 style={{ color: '#64ffda', margin: 0 }}>{name}</h3>
<p style={{ color: '#aaa', margin: '8px 0', fontSize: 13 }}>{desc}</p>
<div style={{ color: '#4caf50', fontWeight: 'bold' }}>{price}</div>
</div>
);
}
const products = [
{ name: 'Quantum Shield', price: '2500 QC', desc: 'Ochrona kwantowa nowej generacji' },
{ name: 'Neural Link', price: '4200 QC', desc: 'Bezposrednie polaczenie z siecia' },
{ name: 'Flux Capacitor', price: '8800 QC', desc: 'Podroze w czasie - wersja beta' },
];
export default function SkeletonDemo() {
const [loaded, setLoaded] = useState(false);
const [loading, setLoading] = useState(false);
const simulateLoad = () => {
setLoaded(false);
setLoading(true);
setTimeout(() => { setLoading(false); setLoaded(true); }, 2500);
};
useEffect(() => { simulateLoad(); }, []);
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: 20, color: '#e0e0e0', fontFamily: 'monospace' }}>
<style>{`@keyframes shimmer { 0% { background-position: 200% 0; } 100% { background-position: -200% 0; } }`}</style>
<h1 style={{ color: '#64ffda' }}>Skeleton Loading States</h1>
<p style={{ color: '#888' }}>Komponenty szkieletowe poprawiaja postrzegana szybkosc ladowania</p>
<button onClick={simulateLoad} style={{
background: '#2196f3', color: '#fff', border: 'none', borderRadius: 6,
padding: '8px 16px', cursor: 'pointer', margin: '12px 0', fontFamily: 'monospace'
}}>
Przeladuj dane
</button>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(220px, 1fr))', gap: 16 }}>
{loading
? [0, 1, 2].map(i => <SkeletonCard key={i} />)
: loaded
? products.map(p => <ProductCard key={p.name} {...p} />)
: null}
</div>
</div>
);
}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. Client Components w App Router oznacza się przez:
2. Revalidation w Next.js służy do:
Zadania praktyczne w grze
- Edytor kodu
Utwórz Client Component z useState i event handlerami dla interaktywnego search bar
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: <Suspense → fallback={<Loading />}> → <C
- Klikanie w kolejności
Ułóż składnię importu komponentu Suspense z React
- Edytor kodu
Utwórz stronę produktu z ISR - data revalidation co 3600 sekund dla dynamicznej trasy [id]
Zadania po tej lekcji
- PytanieClient Components w App Router oznacza się przez:
- PytanieRevalidation w Next.js służy do:
- Zadanie z kodemPraktyka: Utwórz Client Component z useState i event
- Ułóż w kolejnościKolejność: <Suspense → fallback={<Loading />}> → ...
- Kliknij w kolejnościKolejność: import → { → Suspense
- Zadanie z kodemPraktyka: Utwórz stronę produktu z ISR - data revalidation