Kurs Next.js · Moduł 6: Formularze i Server Actions
React Hook Form i zarządzanie stanem formularzy
W tej lekcji8
Formularze są integralną częścią większości aplikacji webowych, ale skuteczne zarządzanie ich stanem, walidacją i obsługą błędów może być wyzwaniem. React Hook Form to jedna z najpopularniejszych bibliotek w ekosystemie React, która została zaprojektowana, aby rozwiązać typowe problemy związane z formularzami, jednocześnie zachowując wysoką wydajność i niską złożoność kodu.
Dlaczego warto użyć React Hook Form?
Przed zgłębieniem szczegółów implementacji, przyjrzyjmy się głównym zaletom React Hook Form w porównaniu do natywnych rozwiązań React:
- Minimalne renderowanie - biblioteka minimalizuje niepotrzebne przerenderowania, co przekłada się na lepszą wydajność
- Mniej kodu boilerplate - w porównaniu do natywnych kontrolowanych komponentów
- Łatwa integracja - działa zarówno z kontrolowanymi, jak i niekontrolowanymi komponentami
- Zaawansowana walidacja - rozbudowane możliwości walidacji, integracja z Yup, Zod, Joi i innymi bibliotekami
- Typowanie TypeScript - pełne wsparcie dla TypeScript
- Wydajność - zoptymalizowana pod kątem wydajności, nawet w złożonych formularzach
Podstawy React Hook Form
Zacznijmy od prostego przykładu formularza logowania:
import { useForm, SubmitHandler } from 'react-hook-form';
type LoginInputs = {
email: string;
password: string;
rememberMe: boolean;
};
export default function LoginForm() {
const {
register,
handleSubmit,
formState: { errors, isSubmitting }
} = useForm<LoginInputs>();
const onSubmit: SubmitHandler<LoginInputs> = async (data) => {
// W rzeczywistej aplikacji wywołalibyśmy tutaj API
console.log('Dane logowania:', data);
// Symulacja opóźnienia sieciowego
await new Promise(resolve => setTimeout(resolve, 1000));
};
return (
<form onSubmit={handleSubmit(onSubmit)} className="space-y-4">
<div>
<label htmlFor="email" className="block text-sm font-medium">
Email
</label>
<input
id="email"
type="email"
className={`mt-1 block w-full rounded-md ${errors.email ? 'border-red-500' : 'border-gray-300'}`}
{...register('email', {
required: 'Email jest wymagany',
pattern: {
value: /^\S+@\S+\.\S+$/,
message: 'Nieprawidłowy format email'
}
})}
/>
{errors.email && (
<p className="text-red-500 text-xs mt-1">{errors.email.message}</p>
)}
</div>
<div>
<label htmlFor="password" className="block text-sm font-medium">
Hasło
</label>
<input
id="password"
type="password"
className={`mt-1 block w-full rounded-md ${errors.password ? 'border-red-500' : 'border-gray-300'}`}
{...register('password', {
required: 'Hasło jest wymagane',
minLength: {
value: 6,
message: 'Hasło musi mieć co najmniej 6 znaków'
}
})}
/>
{errors.password && (
<p className="text-red-500 text-xs mt-1">{errors.password.message}</p>
)}
</div>
<div className="flex items-center">
<input
id="rememberMe"
type="checkbox"
className="h-4 w-4 rounded border-gray-300"
{...register('rememberMe')}
/>
<label htmlFor="rememberMe" className="ml-2 block text-sm">
Zapamiętaj mnie
</label>
</div>
<button
type="submit"
disabled={isSubmitting}
className="w-full py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
>
{isSubmitting ? 'Logowanie...' : 'Zaloguj się'}
</button>
</form>
);
}Główne elementy React Hook Form w powyższym przykładzie:
- useForm - główny hook, który dostarcza metody do zarządzania formularzem
- register - funkcja rejestrująca pola formularza w React Hook Form
- handleSubmit - funkcja opakowująca nasz handler wysyłania formularza
- formState - obiekt zawierający informacje o stanie formularza, w tym błędy i status wysyłania
Zaawansowana walidacja z Zod
React Hook Form doskonale integruje się z bibliotekami walidacyjnymi, takimi jak Zod, co pozwala na tworzenie solidnych schematów walidacji:
import { useForm, SubmitHandler } from 'react-hook-form';
import { zodResolver } from '@hookform/resolvers/zod';
import { z } from 'zod';
// Definicja schematu z Zod
const signupSchema = z.object({
username: z.string()
.min(3, 'Nazwa użytkownika musi mieć co najmniej 3 znaki')
.max(20, 'Nazwa użytkownika może mieć maksymalnie 20 znaków')
.regex(/^[a-zA-Z0-9_]+$/, 'Nazwa użytkownika może zawierać tylko litery, cyfry i podkreślenia'),
email: z.string()
.email('Podaj prawidłowy adres email'),
password: z.string()
.min(8, 'Hasło musi mieć co najmniej 8 znaków')
.regex(/[A-Z]/, 'Hasło musi zawierać co najmniej jedną wielką literę')
.regex(/[a-z]/, 'Hasło musi zawierać co najmniej jedną małą literę')
.regex(/[0-9]/, 'Hasło musi zawierać co najmniej jedną cyfrę'),
confirmPassword: z.string(),
terms: z.boolean().refine(val => val === true, {
message: 'Musisz zaakceptować warunki',
}),
}).refine(data => data.password === data.confirmPassword, {
message: 'Hasła nie są identyczne',
path: ['confirmPassword'],
});
// Typ wynikający ze schematu
type SignupInputs = z.infer<typeof signupSchema>;
export default function SignupForm() {
const {
register,
handleSubmit,
formState: { errors, isSubmitting, isSubmitSuccessful },
reset
} = useForm<SignupInputs>({
resolver: zodResolver(signupSchema),
defaultValues: {
username: '',
email: '',
password: '',
confirmPassword: '',
terms: false
}
});
const onSubmit: SubmitHandler<SignupInputs> = async (data) => {
try {
// Symulacja wysyłania danych do API
await new Promise(resolve => setTimeout(resolve, 1500));
console.log('Dane rejestracji:', data);
// Resetowanie formularza po udanym wysłaniu
reset();
} catch (error) {
console.error('Błąd rejestracji:', error);
}
};
return (
<div className="max-w-md mx-auto p-6 bg-white rounded-lg shadow-md">
<h2 className="text-2xl font-bold mb-6">Rejestracja</h2>
{isSubmitSuccessful && (
<div className="mb-4 p-3 bg-green-100 text-green-700 rounded">
Rejestracja zakończona pomyślnie!
</div>
)}
<form onSubmit={handleSubmit(onSubmit)} className="space-y-4">
<div>
<label htmlFor="username" className="block text-sm font-medium">
Nazwa użytkownika
</label>
<input
id="username"
type="text"
className={`mt-1 block w-full rounded-md ${errors.username ? 'border-red-500' : 'border-gray-300'}`}
{...register('username')}
/>
{errors.username && (
<p className="text-red-500 text-xs mt-1">{errors.username.message}</p>
)}
</div>
<div>
<label htmlFor="email" className="block text-sm font-medium">
Email
</label>
<input
id="email"
type="email"
className={`mt-1 block w-full rounded-md ${errors.email ? 'border-red-500' : 'border-gray-300'}`}
{...register('email')}
/>
{errors.email && (
<p className="text-red-500 text-xs mt-1">{errors.email.message}</p>
)}
</div>
<div>
<label htmlFor="password" className="block text-sm font-medium">
Hasło
</label>
<input
id="password"
type="password"
className={`mt-1 block w-full rounded-md ${errors.password ? 'border-red-500' : 'border-gray-300'}`}
{...register('password')}
/>
{errors.password && (
<p className="text-red-500 text-xs mt-1">{errors.password.message}</p>
)}
</div>
<div>
<label htmlFor="confirmPassword" className="block text-sm font-medium">
Potwierdź hasło
</label>
<input
id="confirmPassword"
type="password"
className={`mt-1 block w-full rounded-md ${errors.confirmPassword ? 'border-red-500' : 'border-gray-300'}`}
{...register('confirmPassword')}
/>
{errors.confirmPassword && (
<p className="text-red-500 text-xs mt-1">{errors.confirmPassword.message}</p>
)}
</div>
<div className="flex items-center">
<input
id="terms"
type="checkbox"
className={`h-4 w-4 rounded ${errors.terms ? 'border-red-500' : 'border-gray-300'}`}
{...register('terms')}
/>
<label htmlFor="terms" className="ml-2 block text-sm">
Akceptuję warunki korzystania z serwisu
</label>
</div>
{errors.terms && (
<p className="text-red-500 text-xs">{errors.terms.message}</p>
)}
<button
type="submit"
disabled={isSubmitting}
className="w-full py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
>
{isSubmitting ? 'Rejestracja...' : 'Zarejestruj się'}
</button>
</form>
</div>
);
}Kluczowe elementy tego przykładu:
- zodResolver - adapter integrujący Zod z React Hook Form
- Zaawansowane reguły walidacji - złożone wyrażenia regularne, minimalna długość, itp.
- Funkcja refine - do niestandardowych warunków walidacji, takich jak porównywanie haseł
- z.infer<typeof schema> - automatyczne generowanie typu z definicji schematu
Dynamiczne formularze i pola warunkowe
React Hook Form doskonale radzi sobie z dynamicznymi formularzami, w których pola mogą pojawiać się lub znikać w zależności od warunków:
import { useForm, useWatch, SubmitHandler, Controller } from 'react-hook-form';
import { useState } from 'react';
type DeliveryMethod = 'standard' | 'express' | 'pickup';
type CheckoutInputs = {
firstName: string;
lastName: string;
email: string;
deliveryMethod: DeliveryMethod;
address?: string;
city?: string;
postalCode?: string;
pickupLocation?: string;
};
export default function DynamicCheckoutForm() {
const {
register,
handleSubmit,
control,
formState: { errors, isSubmitting }
} = useForm<CheckoutInputs>({
defaultValues: {
firstName: '',
lastName: '',
email: '',
deliveryMethod: 'standard',
}
});
// Używamy useWatch, aby obserwować zmiany w wybranej metodzie dostawy
const deliveryMethod = useWatch({
control,
name: 'deliveryMethod',
defaultValue: 'standard',
});
// Sprawdzamy, czy potrzebujemy adresu dostawy
const needsShippingAddress = deliveryMethod === 'standard' || deliveryMethod === 'express';
const onSubmit: SubmitHandler<CheckoutInputs> = async (data) => {
// Symulacja opóźnienia API
await new Promise(resolve => setTimeout(resolve, 1000));
console.log('Dane zamówienia:', data);
};
return (
<div className="max-w-md mx-auto p-6 bg-white rounded-lg shadow-md">
<h2 className="text-2xl font-bold mb-6">Finalizacja zamówienia</h2>
<form onSubmit={handleSubmit(onSubmit)} className="space-y-6">
<div className="grid grid-cols-2 gap-4">
<div>
<label htmlFor="firstName" className="block text-sm font-medium">
Imię
</label>
<input
id="firstName"
type="text"
className={`mt-1 block w-full rounded-md ${errors.firstName ? 'border-red-500' : 'border-gray-300'}`}
{...register('firstName', { required: 'Imię jest wymagane' })}
/>
{errors.firstName && (
<p className="text-red-500 text-xs mt-1">{errors.firstName.message}</p>
)}
</div>
<div>
<label htmlFor="lastName" className="block text-sm font-medium">
Nazwisko
</label>
<input
id="lastName"
type="text"
className={`mt-1 block w-full rounded-md ${errors.lastName ? 'border-red-500' : 'border-gray-300'}`}
{...register('lastName', { required: 'Nazwisko jest wymagane' })}
/>
{errors.lastName && (
<p className="text-red-500 text-xs mt-1">{errors.lastName.message}</p>
)}
</div>
</div>
<div>
<label htmlFor="email" className="block text-sm font-medium">
Email
</label>
<input
id="email"
type="email"
className={`mt-1 block w-full rounded-md ${errors.email ? 'border-red-500' : 'border-gray-300'}`}
{...register('email', {
required: 'Email jest wymagany',
pattern: {
value: /^\S+@\S+\.\S+$/,
message: 'Nieprawidłowy format email'
}
})}
/>
{errors.email && (
<p className="text-red-500 text-xs mt-1">{errors.email.message}</p>
)}
</div>
<div>
<label className="block text-sm font-medium mb-2">
Metoda dostawy
</label>
<div className="space-y-2">
<label className="flex items-center">
<input
type="radio"
value="standard"
className="mr-2"
{...register('deliveryMethod')}
/>
Dostawa standardowa (2-3 dni robocze)
</label>
<label className="flex items-center">
<input
type="radio"
value="express"
className="mr-2"
{...register('deliveryMethod')}
/>
Dostawa ekspresowa (24h)
</label>
<label className="flex items-center">
<input
type="radio"
value="pickup"
className="mr-2"
{...register('deliveryMethod')}
/>
Odbiór osobisty
</label>
</div>
</div>
{needsShippingAddress && (
<div className="space-y-4 p-4 bg-gray-50 rounded">
<h3 className="font-medium">Adres dostawy</h3>
<div>
<label htmlFor="address" className="block text-sm font-medium">
Adres
</label>
<input
id="address"
type="text"
className={`mt-1 block w-full rounded-md ${errors.address ? 'border-red-500' : 'border-gray-300'}`}
{...register('address', { required: 'Adres jest wymagany' })}
/>
{errors.address && (
<p className="text-red-500 text-xs mt-1">{errors.address.message}</p>
)}
</div>
<div className="grid grid-cols-2 gap-4">
<div>
<label htmlFor="city" className="block text-sm font-medium">
Miasto
</label>
<input
id="city"
type="text"
className={`mt-1 block w-full rounded-md ${errors.city ? 'border-red-500' : 'border-gray-300'}`}
{...register('city', { required: 'Miasto jest wymagane' })}
/>
{errors.city && (
<p className="text-red-500 text-xs mt-1">{errors.city.message}</p>
)}
</div>
<div>
<label htmlFor="postalCode" className="block text-sm font-medium">
Kod pocztowy
</label>
<input
id="postalCode"
type="text"
className={`mt-1 block w-full rounded-md ${errors.postalCode ? 'border-red-500' : 'border-gray-300'}`}
{...register('postalCode', {
required: 'Kod pocztowy jest wymagany',
pattern: {
value: /^\d{2}-\d{3}$/,
message: 'Format: 00-000'
}
})}
/>
{errors.postalCode && (
<p className="text-red-500 text-xs mt-1">{errors.postalCode.message}</p>
)}
</div>
</div>
</div>
)}
{deliveryMethod === 'pickup' && (
<div>
<label htmlFor="pickupLocation" className="block text-sm font-medium">
Punkt odbioru
</label>
<select
id="pickupLocation"
className={`mt-1 block w-full rounded-md ${errors.pickupLocation ? 'border-red-500' : 'border-gray-300'}`}
{...register('pickupLocation', { required: 'Wybierz punkt odbioru' })}
>
<option value="">Wybierz punkt odbioru</option>
<option value="warszawa-centrum">Warszawa - Centrum</option>
<option value="warszawa-mokotow">Warszawa - Mokotów</option>
<option value="krakow-centrum">Kraków - Centrum</option>
<option value="poznan-centrum">Poznań - Centrum</option>
</select>
{errors.pickupLocation && (
<p className="text-red-500 text-xs mt-1">{errors.pickupLocation.message}</p>
)}
</div>
)}
<button
type="submit"
disabled={isSubmitting}
className="w-full py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
>
{isSubmitting ? 'Przetwarzanie...' : 'Złóż zamówienie'}
</button>
</form>
</div>
);
}Kluczowe elementy dynamicznego formularza:
- useWatch - pozwala na obserwowanie zmian wybranych pól formularza bez wywoływania przerenderowań całego formularza
- Warunkowo renderowane sekcje - w zależności od wybranej metody dostawy
- Warunkowa walidacja - różne reguły walidacji dla różnych sekcji formularza
Formularze wielostopniowe
React Hook Form doskonale sprawdza się również w wielostopniowych formularzach:
import { useForm, SubmitHandler, FormProvider, useFormContext } from 'react-hook-form';
import { zodResolver } from '@hookform/resolvers/zod';
import { z } from 'zod';
import { useState } from 'react';
// Schemat danych osobowych
const personalInfoSchema = z.object({
firstName: z.string().min(1, 'Imię jest wymagane'),
lastName: z.string().min(1, 'Nazwisko jest wymagane'),
email: z.string().email('Nieprawidłowy format email'),
phoneNumber: z.string().regex(/^[0-9]{9}$/, 'Numer telefonu musi mieć 9 cyfr')
});
// Schemat adresu
const addressSchema = z.object({
street: z.string().min(1, 'Ulica jest wymagana'),
city: z.string().min(1, 'Miasto jest wymagane'),
postalCode: z.string().regex(/^\d{2}-\d{3}$/, 'Kod pocztowy musi mieć format 00-000'),
country: z.string().min(1, 'Kraj jest wymagany')
});
// Schemat płatności
const paymentSchema = z.object({
cardName: z.string().min(1, 'Imię i nazwisko na karcie jest wymagane'),
cardNumber: z.string().regex(/^[0-9]{16}$/, 'Numer karty musi mieć 16 cyfr'),
expiryDate: z.string().regex(/^(0[1-9]|1[0-2])\/[0-9]{2}$/, 'Format: MM/RR'),
cvv: z.string().regex(/^[0-9]{3,4}$/, 'CVV musi mieć 3 lub 4 cyfry')
});
// Łączny schemat
const formSchema = z.object({
personalInfo: personalInfoSchema,
address: addressSchema,
payment: paymentSchema
});
type MultiStepFormData = z.infer<typeof formSchema>;
// Komponent kroku formularza z danymi osobowymi
function PersonalInfoStep() {
const { register, formState: { errors } } = useFormContext<MultiStepFormData>();
return (
<div className="space-y-4">
<h2 className="text-xl font-bold">Dane osobowe</h2>
<div className="grid grid-cols-2 gap-4">
<div>
<label htmlFor="firstName" className="block text-sm font-medium">
Imię
</label>
<input
id="firstName"
type="text"
className={`mt-1 block w-full rounded-md ${
errors.personalInfo?.firstName ? 'border-red-500' : 'border-gray-300'
}`}
{...register('personalInfo.firstName')}
/>
{errors.personalInfo?.firstName && (
<p className="text-red-500 text-xs mt-1">{errors.personalInfo.firstName.message}</p>
)}
</div>
<div>
<label htmlFor="lastName" className="block text-sm font-medium">
Nazwisko
</label>
<input
id="lastName"
type="text"
className={`mt-1 block w-full rounded-md ${
errors.personalInfo?.lastName ? 'border-red-500' : 'border-gray-300'
}`}
{...register('personalInfo.lastName')}
/>
{errors.personalInfo?.lastName && (
<p className="text-red-500 text-xs mt-1">{errors.personalInfo.lastName.message}</p>
)}
</div>
</div>
<div>
<label htmlFor="email" className="block text-sm font-medium">
Email
</label>
<input
id="email"
type="email"
className={`mt-1 block w-full rounded-md ${
errors.personalInfo?.email ? 'border-red-500' : 'border-gray-300'
}`}
{...register('personalInfo.email')}
/>
{errors.personalInfo?.email && (
<p className="text-red-500 text-xs mt-1">{errors.personalInfo.email.message}</p>
)}
</div>
<div>
<label htmlFor="phoneNumber" className="block text-sm font-medium">
Numer telefonu
</label>
<input
id="phoneNumber"
type="tel"
className={`mt-1 block w-full rounded-md ${
errors.personalInfo?.phoneNumber ? 'border-red-500' : 'border-gray-300'
}`}
{...register('personalInfo.phoneNumber')}
/>
{errors.personalInfo?.phoneNumber && (
<p className="text-red-500 text-xs mt-1">{errors.personalInfo.phoneNumber.message}</p>
)}
</div>
</div>
);
}
// Komponent kroku formularza z adresem
function AddressStep() {
const { register, formState: { errors } } = useFormContext<MultiStepFormData>();
return (
<div className="space-y-4">
<h2 className="text-xl font-bold">Adres dostawy</h2>
<div>
<label htmlFor="street" className="block text-sm font-medium">
Ulica i numer
</label>
<input
id="street"
type="text"
className={`mt-1 block w-full rounded-md ${
errors.address?.street ? 'border-red-500' : 'border-gray-300'
}`}
{...register('address.street')}
/>
{errors.address?.street && (
<p className="text-red-500 text-xs mt-1">{errors.address.street.message}</p>
)}
</div>
<div className="grid grid-cols-2 gap-4">
<div>
<label htmlFor="city" className="block text-sm font-medium">
Miasto
</label>
<input
id="city"
type="text"
className={`mt-1 block w-full rounded-md ${
errors.address?.city ? 'border-red-500' : 'border-gray-300'
}`}
{...register('address.city')}
/>
{errors.address?.city && (
<p className="text-red-500 text-xs mt-1">{errors.address.city.message}</p>
)}
</div>
<div>
<label htmlFor="postalCode" className="block text-sm font-medium">
Kod pocztowy
</label>
<input
id="postalCode"
type="text"
className={`mt-1 block w-full rounded-md ${
errors.address?.postalCode ? 'border-red-500' : 'border-gray-300'
}`}
{...register('address.postalCode')}
/>
{errors.address?.postalCode && (
<p className="text-red-500 text-xs mt-1">{errors.address.postalCode.message}</p>
)}
</div>
</div>
<div>
<label htmlFor="country" className="block text-sm font-medium">
Kraj
</label>
<select
id="country"
className={`mt-1 block w-full rounded-md ${
errors.address?.country ? 'border-red-500' : 'border-gray-300'
}`}
{...register('address.country')}
>
<option value="">Wybierz kraj</option>
<option value="Poland">Polska</option>
<option value="Germany">Niemcy</option>
<option value="France">Francja</option>
<option value="UK">Wielka Brytania</option>
</select>
{errors.address?.country && (
<p className="text-red-500 text-xs mt-1">{errors.address.country.message}</p>
)}
</div>
</div>
);
}
// Komponent kroku formularza z płatnością
function PaymentStep() {
const { register, formState: { errors } } = useFormContext<MultiStepFormData>();
return (
<div className="space-y-4">
<h2 className="text-xl font-bold">Metoda płatności</h2>
<div>
<label htmlFor="cardName" className="block text-sm font-medium">
Imię i nazwisko na karcie
</label>
<input
id="cardName"
type="text"
className={`mt-1 block w-full rounded-md ${
errors.payment?.cardName ? 'border-red-500' : 'border-gray-300'
}`}
{...register('payment.cardName')}
/>
{errors.payment?.cardName && (
<p className="text-red-500 text-xs mt-1">{errors.payment.cardName.message}</p>
)}
</div>
<div>
<label htmlFor="cardNumber" className="block text-sm font-medium">
Numer karty
</label>
<input
id="cardNumber"
type="text"
className={`mt-1 block w-full rounded-md ${
errors.payment?.cardNumber ? 'border-red-500' : 'border-gray-300'
}`}
{...register('payment.cardNumber')}
/>
{errors.payment?.cardNumber && (
<p className="text-red-500 text-xs mt-1">{errors.payment.cardNumber.message}</p>
)}
</div>
<div className="grid grid-cols-2 gap-4">
<div>
<label htmlFor="expiryDate" className="block text-sm font-medium">
Data ważności
</label>
<input
id="expiryDate"
type="text"
className={`mt-1 block w-full rounded-md ${
errors.payment?.expiryDate ? 'border-red-500' : 'border-gray-300'
}`}
{...register('payment.expiryDate')}
/>
{errors.payment?.expiryDate && (
<p className="text-red-500 text-xs mt-1">{errors.payment.expiryDate.message}</p>
)}
</div>
<div>
<label htmlFor="cvv" className="block text-sm font-medium">
CVV
</label>
<input
id="cvv"
type="text"
className={`mt-1 block w-full rounded-md ${
errors.payment?.cvv ? 'border-red-500' : 'border-gray-300'
}`}
{...register('payment.cvv')}
/>
{errors.payment?.cvv && (
<p className="text-red-500 text-xs mt-1">{errors.payment.cvv.message}</p>
)}
</div>
</div>
</div>
);
}
// Komponent podsumowania
function SummaryStep({ data }: { data: MultiStepFormData }) {
return (
<div className="space-y-6">
<h2 className="text-xl font-bold">Podsumowanie zamówienia</h2>
<div className="bg-gray-50 p-4 rounded">
<h3 className="font-medium mb-2">Dane osobowe</h3>
<p>{data.personalInfo.firstName} {data.personalInfo.lastName}</p>
<p>{data.personalInfo.email}</p>
<p>Tel: {data.personalInfo.phoneNumber}</p>
</div>
<div className="bg-gray-50 p-4 rounded">
<h3 className="font-medium mb-2">Adres dostawy</h3>
<p>{data.address.street}</p>
<p>{data.address.postalCode} {data.address.city}</p>
<p>{data.address.country}</p>
</div>
<div className="bg-gray-50 p-4 rounded">
<h3 className="font-medium mb-2">Metoda płatności</h3>
<p>{data.payment.cardName}</p>
<p>Karta: **** **** **** {data.payment.cardNumber.slice(-4)}</p>
<p>Ważna do: {data.payment.expiryDate}</p>
</div>
</div>
);
}
export default function MultiStepForm() {
const [currentStep, setCurrentStep] = useState(0);
const [isSubmitted, setIsSubmitted] = useState(false);
const methods = useForm<MultiStepFormData>({
resolver: zodResolver(formSchema),
mode: 'onBlur',
defaultValues: {
personalInfo: {
firstName: '',
lastName: '',
email: '',
phoneNumber: ''
},
address: {
street: '',
city: '',
postalCode: '',
country: ''
},
payment: {
cardName: '',
cardNumber: '',
expiryDate: '',
cvv: ''
}
}
});
const steps = [
{ name: 'Dane osobowe', component: <PersonalInfoStep /> },
{ name: 'Adres', component: <AddressStep /> },
{ name: 'Płatność', component: <PaymentStep /> },
{ name: 'Podsumowanie', component: <SummaryStep data={methods.getValues()} /> }
];
const onSubmit: SubmitHandler<MultiStepFormData> = async (data) => {
// Procesów finalnej wysyłki danych
if (currentStep === steps.length - 1) {
await new Promise(resolve => setTimeout(resolve, 1500));
console.log('Zamówienie złożone:', data);
setIsSubmitted(true);
} else {
// Przechodzimy do następnego kroku
setCurrentStep(prev => prev + 1);
}
};
const handlePrevStep = () => {
setCurrentStep(prev => Math.max(0, prev - 1));
};
const validateCurrentStep = async () => {
let isValid = false;
switch (currentStep) {
case 0:
isValid = await methods.trigger('personalInfo');
break;
case 1:
isValid = await methods.trigger('address');
break;
case 2:
isValid = await methods.trigger('payment');
break;
case 3:
isValid = true; // Podsumowanie nie wymaga walidacji
break;
}
return isValid;
};
const handleNextStep = async () => {
const isValid = await validateCurrentStep();
if (isValid) {
setCurrentStep(prev => Math.min(steps.length - 1, prev + 1));
}
};
return (
<div className="max-w-2xl mx-auto p-6 bg-white rounded-lg shadow-md">
{isSubmitted ? (
<div className="text-center py-8">
<svg className="w-16 h-16 text-green-500 mx-auto mb-4" fill="none" viewBox="0 0 24 24" stroke="currentColor">
<path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M5 13l4 4L19 7" />
</svg>
<h2 className="text-2xl font-bold mb-2">Zamówienie przyjęte!</h2>
<p className="text-gray-600 mb-4">Dziękujemy za złożenie zamówienia. Szczegóły wysłaliśmy na podany adres email.</p>
<button
onClick={() => {
methods.reset();
setCurrentStep(0);
setIsSubmitted(false);
}}
className="px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700"
>
Złóż nowe zamówienie
</button>
</div>
) : (
<>
{/* Pasek postępu */}
<div className="mb-8">
<div className="flex justify-between mb-2">
{steps.map((step, index) => (
<div key={index} className="flex flex-col items-center">
<div
className={`w-8 h-8 flex items-center justify-center rounded-full ${index <= currentStep ? 'bg-blue-600 text-white' : 'bg-gray-200 text-gray-600'}`}
>
{index + 1}
</div>
<span className="text-xs mt-1">{step.name}</span>
</div>
))}
</div>
<div className="relative w-full h-2 bg-gray-200 rounded-full overflow-hidden">
<div
className="absolute h-full bg-blue-600 transition-all duration-300"
style={{ width: `${(currentStep / (steps.length - 1)) * 100}%` }}
></div>
</div>
</div>
<FormProvider {...methods}>
<form onSubmit={methods.handleSubmit(onSubmit)} className="space-y-8">
{steps[currentStep].component}
<div className="flex justify-between mt-8">
<button
type="button"
onClick={handlePrevStep}
disabled={currentStep === 0}
className="px-4 py-2 border border-gray-300 rounded-md hover:bg-gray-50 disabled:opacity-50"
>
Wstecz
</button>
{currentStep < steps.length - 1 ? (
<button
type="button"
onClick={handleNextStep}
className="px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700"
>
Dalej
</button>
) : (
<button
type="submit"
className="px-4 py-2 bg-green-600 text-white rounded-md hover:bg-green-700"
>
{methods.formState.isSubmitting ? 'Przetwarzanie...' : 'Złóż zamówienie'}
</button>
)}
</div>
</form>
</FormProvider>
</>
)}
</div>
);
}Główne elementy wielostopniowego formularza:
- FormProvider - dostarcza kontekst formularza dla zagnieżdżonych komponentów
- useFormContext - pozwala komponentom potomnym na dostęp do metod formularza
- Zagnieżdżone pola - przy użyciu notacji kropkowej (np.
personalInfo.firstName) - Walidacja po krokach - z wykorzystaniem metody
triggerdo walidacji konkretnych części formularza
Integracja z Server Actions w Next.js
React Hook Form można łatwo połączyć z Server Actions w Next.js:
// app/newsletter/page.tsx
'use client';
import { useForm, SubmitHandler } from 'react-hook-form';
import { zodResolver } from '@hookform/resolvers/zod';
import { z } from 'zod';
import { useState } from 'react';
import { subscribeToNewsletter } from './actions';
const newsletterSchema = z.object({
email: z.string().email('Podaj prawidłowy adres email'),
firstName: z.string().min(1, 'Imię jest wymagane'),
preferences: z.object({
marketing: z.boolean().optional(),
updates: z.boolean().optional(),
news: z.boolean().optional()
}).refine(prefs => prefs.marketing || prefs.updates || prefs.news, {
message: 'Wybierz co najmniej jedną preferencję',
path: ['_errors']
})
});
type NewsletterFormInputs = z.infer<typeof newsletterSchema>;
export default function NewsletterForm() {
const [submitStatus, setSubmitStatus] = useState<{ success: boolean; message: string } | null>(null);
const {
register,
handleSubmit,
formState: { errors, isSubmitting },
reset
} = useForm<NewsletterFormInputs>({
resolver: zodResolver(newsletterSchema),
defaultValues: {
email: '',
firstName: '',
preferences: {
marketing: false,
updates: false,
news: false
}
}
});
const onSubmit: SubmitHandler<NewsletterFormInputs> = async (data) => {
try {
// Wywołanie Server Action
const result = await subscribeToNewsletter(data);
setSubmitStatus({
success: result.success,
message: result.message
});
if (result.success) {
reset(); // Resetowanie formularza po udanym wysyłaniu
}
} catch (error) {
setSubmitStatus({
success: false,
message: 'Wystąpił nieoczekiwany błąd. Spróbuj ponownie później.'
});
}
};
return (
<div className="max-w-md mx-auto p-6 bg-white rounded-lg shadow-md">
<h2 className="text-2xl font-bold mb-6">Zapisz się do newslettera</h2>
{submitStatus && (
<div className={`mb-4 p-3 rounded ${submitStatus.success ? 'bg-green-100 text-green-700' : 'bg-red-100 text-red-700'}`}>
{submitStatus.message}
</div>
)}
<form onSubmit={handleSubmit(onSubmit)} className="space-y-4">
<div>
<label htmlFor="email" className="block text-sm font-medium">
Email
</label>
<input
id="email"
type="email"
className={`mt-1 block w-full rounded-md ${errors.email ? 'border-red-500' : 'border-gray-300'}`}
{...register('email')}
/>
{errors.email && (
<p className="text-red-500 text-xs mt-1">{errors.email.message}</p>
)}
</div>
<div>
<label htmlFor="firstName" className="block text-sm font-medium">
Imię
</label>
<input
id="firstName"
type="text"
className={`mt-1 block w-full rounded-md ${errors.firstName ? 'border-red-500' : 'border-gray-300'}`}
{...register('firstName')}
/>
{errors.firstName && (
<p className="text-red-500 text-xs mt-1">{errors.firstName.message}</p>
)}
</div>
<div>
<label className="block text-sm font-medium mb-2">
Preferencje newslettera
</label>
<div className="space-y-2">
<label className="flex items-center">
<input
type="checkbox"
className="h-4 w-4 rounded border-gray-300 mr-2"
{...register('preferences.marketing')}
/>
Informacje marketingowe i promocje
</label>
<label className="flex items-center">
<input
type="checkbox"
className="h-4 w-4 rounded border-gray-300 mr-2"
{...register('preferences.updates')}
/>
Aktualizacje produktów i usług
</label>
<label className="flex items-center">
<input
type="checkbox"
className="h-4 w-4 rounded border-gray-300 mr-2"
{...register('preferences.news')}
/>
Wiadomości branżowe
</label>
</div>
{errors.preferences?.['_errors'] && (
<p className="text-red-500 text-xs mt-1">{errors.preferences['_errors'].join(', ')}</p>
)}
</div>
<button
type="submit"
disabled={isSubmitting}
className="w-full py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:opacity-50"
>
{isSubmitting ? 'Wysyłanie...' : 'Zapisz się'}
</button>
</form>
</div>
);
}I plik z Server Action:
// app/newsletter/actions.ts
'use server';
import { z } from 'zod';
const newsletterSchema = z.object({
email: z.string().email(),
firstName: z.string().min(1),
preferences: z.object({
marketing: z.boolean().optional(),
updates: z.boolean().optional(),
news: z.boolean().optional()
})
});
type NewsletterData = z.infer<typeof newsletterSchema>;
export async function subscribeToNewsletter(data: NewsletterData) {
// Walidacja danych na serwerze dla bezpieczeństwa
const validationResult = newsletterSchema.safeParse(data);
if (!validationResult.success) {
return {
success: false,
message: 'Nieprawidłowe dane. Sprawdź formularz i spróbuj ponownie.'
};
}
try {
// Symulacja opóźnienia API
await new Promise(resolve => setTimeout(resolve, 1000));
// Tutaj byłby rzeczywisty kod zapisujący użytkownika do newslettera
// np. wywołanie API, zapis do bazy danych itp.
console.log('Zapisano do newslettera:', validationResult.data);
return {
success: true,
message: 'Dziękujemy za zapisanie się do newslettera!'
};
} catch (error) {
console.error('Błąd podczas zapisywania do newslettera:', error);
return {
success: false,
message: 'Wystąpił błąd podczas przetwarzania. Spróbuj ponownie później.'
};
}
}Główne elementy integracji React Hook Form z Server Actions:
- Typowanie wspólne - ten sam typ danych jest używany zarówno po stronie klienta, jak i serwera
- Walidacja dwustronna - dane są walidowane zarówno przez React Hook Form, jak i na serwerze
- Obsługa błędów - kompleksowa obsługa błędów po obu stronach
Dobre praktyki i wskazówki
Używaj TypeScript - zapewnia to statyczną typizację i umożliwia wykrywanie błędów na etapie kompilacji
Rozdzielaj komponenty - dziel duże formularze na mniejsze, zarządzalne komponenty
Korzystaj z mode: 'onBlur' - waliduj formularze po opuszczeniu pola, a nie przy każdej zmianie:
const { register } = useForm({ mode: 'onBlur' });Używaj shouldUnregister - dla dynamicznych pól formularza, które mogą pojawiać się i znikać:
const { register } = useForm({ shouldUnregister: true });Wykorzystaj setValue dla złożonych przypadków - do programowego ustawiania wartości:
setValue('field', value, { shouldValidate: true, shouldDirty: true });Używaj transform do formatowania danych:
register('amount', { setValueAs: value => parseFloat(value) || 0 });
Podsumowanie
React Hook Form to potężne narzędzie, które znacząco upraszcza tworzenie i zarządzanie formularzami w React. Główne zalety:
- Wydajność - minimalne przerenderowania komponentów
- Mniejsza ilość kodu - mniej boilerplate'u w porównaniu do natywnych kontrolowanych komponentów
- Elastyczność - działa zarówno z kontrolowanymi, jak i niekontrolowanymi komponentami
- Zaawansowana walidacja - zwłaszcza w połączeniu z bibliotekami takimi jak Zod czy Yup
- TypeScript - pełne wsparcie dla typowania
Podłączając React Hook Form do Server Actions w Next.js, możesz tworzyć wydajne, bezpieczne i przyjazne dla użytkownika formularze, które zachowują się dobrze zarówno z włączonym JavaScript, jak i bez niego (dzięki progresywnemu ulepszaniu w Next.js).
Właściwe zarządzanie formularzami jest kluczowe dla tworzenia wysokiej jakości aplikacji webowych, a React Hook Form sprawia, że proces ten staje się znacznie prostszy i przyjemniejszy zarówno dla developerów, jak i użytkowników końcowych.
Kod do tej lekcji: App.tsx
import React, { useState } from 'react';
// Symulacja React Hook Form - useForm, register, handleSubmit
// (bez zewnetrznej biblioteki, aby dzialalo w sandpack)
type FormValues = { username: string; email: string; age: string; bio: string };
type Errors = Partial<Record<keyof FormValues, string>>;
// Uproszczona implementacja useForm
function useForm() {
const [values, setValues] = useState<FormValues>({ username: '', email: '', age: '', bio: '' });
const [errors, setErrors] = useState<Errors>({});
const [touched, setTouched] = useState<Set<string>>(new Set());
const register = (name: keyof FormValues) => ({
value: values[name],
onChange: (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => {
setValues(prev => ({ ...prev, [name]: e.target.value }));
if (touched.has(name)) validate({ ...values, [name]: e.target.value });
},
onBlur: () => {
setTouched(prev => new Set(prev).add(name));
validate(values);
},
});
const validate = (vals: FormValues): boolean => {
const errs: Errors = {};
if (!vals.username) errs.username = 'Nazwa uzytkownika jest wymagana';
if (!vals.email) errs.email = 'Email jest wymagany';
else if (!/\S+@\S+\.\S+/.test(vals.email)) errs.email = 'Nieprawidlowy format email';
if (vals.age && (isNaN(Number(vals.age)) || Number(vals.age) < 1)) errs.age = 'Podaj prawidlowy wiek';
setErrors(errs);
return Object.keys(errs).length === 0;
};
const handleSubmit = (onValid: (data: FormValues) => void) => (e: React.FormEvent) => {
e.preventDefault();
setTouched(new Set(Object.keys(values)));
if (validate(values)) onValid(values);
};
return { register, handleSubmit, errors, values };
}
export default function ReactHookFormDemo() {
const { register, handleSubmit, errors, values } = useForm();
const [submitted, setSubmitted] = useState<FormValues | null>(null);
const onSubmit = (data: FormValues) => setSubmitted(data);
const inputStyle: React.CSSProperties = {
width: '100%', padding: '10px', background: '#0d1117',
border: '1px solid #333', borderRadius: 6, color: '#e0e0e0',
fontFamily: 'monospace', fontSize: 13, boxSizing: 'border-box'
};
const errorStyle: React.CSSProperties = { color: '#f44336', fontSize: 11, marginTop: 4 };
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: 20, color: '#e0e0e0', fontFamily: 'monospace' }}>
<h1 style={{ color: '#64ffda' }}>React Hook Form</h1>
<p style={{ color: '#888', fontSize: 13, marginBottom: 16 }}>
useForm + register + handleSubmit - minimalne re-rendery, latwa walidacja.
</p>
<form onSubmit={handleSubmit(onSubmit)} style={{ maxWidth: 400 }}>
<div style={{ marginBottom: 12 }}>
<label style={{ color: '#64ffda', fontSize: 12, display: 'block', marginBottom: 4 }}>
Username * <code style={{ color: '#555' }}>...register('username')</code>
</label>
<input {...register('username')} style={{ ...inputStyle, borderColor: errors.username ? '#f44336' : '#333' }} />
{errors.username && <div style={errorStyle}>{errors.username}</div>}
</div>
<div style={{ marginBottom: 12 }}>
<label style={{ color: '#64ffda', fontSize: 12, display: 'block', marginBottom: 4 }}>
Email * <code style={{ color: '#555' }}>...register('email')</code>
</label>
<input {...register('email')} style={{ ...inputStyle, borderColor: errors.email ? '#f44336' : '#333' }} />
{errors.email && <div style={errorStyle}>{errors.email}</div>}
</div>
<div style={{ marginBottom: 12 }}>
<label style={{ color: '#64ffda', fontSize: 12, display: 'block', marginBottom: 4 }}>Wiek</label>
<input {...register('age')} style={{ ...inputStyle, borderColor: errors.age ? '#f44336' : '#333' }} />
{errors.age && <div style={errorStyle}>{errors.age}</div>}
</div>
<div style={{ marginBottom: 12 }}>
<label style={{ color: '#64ffda', fontSize: 12, display: 'block', marginBottom: 4 }}>Bio</label>
<textarea {...register('bio')} rows={2} style={{ ...inputStyle, resize: 'vertical' }} />
</div>
<button type="submit" style={{
background: '#9c27b0', color: '#fff', border: 'none', borderRadius: 6,
padding: '10px 20px', cursor: 'pointer', fontFamily: 'monospace', width: '100%'
}}>
handleSubmit(onSubmit)
</button>
</form>
{submitted && (
<div style={{ marginTop: 16, background: '#1b5e20', borderRadius: 8, padding: 12, maxWidth: 400, border: '1px solid #4caf50' }}>
<div style={{ color: '#4caf50', marginBottom: 4 }}>Dane zwalidowane i wyslane!</div>
<pre style={{ color: '#ccc', fontSize: 11, margin: 0 }}>{JSON.stringify(submitted, null, 2)}</pre>
</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. React Hook Form to:
Zadania praktyczne w grze
- Edytor kodu
Zbuduj interfejs z interaktywnymi formularzami
- Układanie w poziomie
Ułóż składnię elementu form z onSubmit w React
- Klikanie w kolejności
Ułóż elementy w prawidłowej kolejności: const → { → register,
- Edytor kodu
Stwórz formularz logowania z walidacją pól email i hasła