Kurs Next.js · Moduł 6: Formularze i Server Actions

React Hook Form i zarządzanie stanem formularzy

19 min czytania ·
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:

  1. Minimalne renderowanie - biblioteka minimalizuje niepotrzebne przerenderowania, co przekłada się na lepszą wydajność
  2. Mniej kodu boilerplate - w porównaniu do natywnych kontrolowanych komponentów
  3. Łatwa integracja - działa zarówno z kontrolowanymi, jak i niekontrolowanymi komponentami
  4. Zaawansowana walidacja - rozbudowane możliwości walidacji, integracja z Yup, Zod, Joi i innymi bibliotekami
  5. Typowanie TypeScript - pełne wsparcie dla TypeScript
  6. 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:

  1. useForm - główny hook, który dostarcza metody do zarządzania formularzem
  2. register - funkcja rejestrująca pola formularza w React Hook Form
  3. handleSubmit - funkcja opakowująca nasz handler wysyłania formularza
  4. 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:

  1. zodResolver - adapter integrujący Zod z React Hook Form
  2. Zaawansowane reguły walidacji - złożone wyrażenia regularne, minimalna długość, itp.
  3. Funkcja refine - do niestandardowych warunków walidacji, takich jak porównywanie haseł
  4. 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:

  1. useWatch - pozwala na obserwowanie zmian wybranych pól formularza bez wywoływania przerenderowań całego formularza
  2. Warunkowo renderowane sekcje - w zależności od wybranej metody dostawy
  3. 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:

  1. FormProvider - dostarcza kontekst formularza dla zagnieżdżonych komponentów
  2. useFormContext - pozwala komponentom potomnym na dostęp do metod formularza
  3. Zagnieżdżone pola - przy użyciu notacji kropkowej (np. personalInfo.firstName)
  4. Walidacja po krokach - z wykorzystaniem metody trigger do 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:

  1. Typowanie wspólne - ten sam typ danych jest używany zarówno po stronie klienta, jak i serwera
  2. Walidacja dwustronna - dane są walidowane zarówno przez React Hook Form, jak i na serwerze
  3. Obsługa błędów - kompleksowa obsługa błędów po obu stronach

Dobre praktyki i wskazówki

  1. Używaj TypeScript - zapewnia to statyczną typizację i umożliwia wykrywanie błędów na etapie kompilacji

  2. Rozdzielaj komponenty - dziel duże formularze na mniejsze, zarządzalne komponenty

  3. Korzystaj z mode: 'onBlur' - waliduj formularze po opuszczeniu pola, a nie przy każdej zmianie:

    const { register } = useForm({ mode: 'onBlur' });
  4. Używaj shouldUnregister - dla dynamicznych pól formularza, które mogą pojawiać się i znikać:

    const { register } = useForm({ shouldUnregister: true });
  5. Wykorzystaj setValue dla złożonych przypadków - do programowego ustawiania wartości:

    setValue('field', value, { shouldValidate: true, shouldDirty: true });
  6. 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. 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

  1. PytanieReact Hook Form to:
  2. Zadanie z kodemPraktyka: Interaktywne formularze
  3. Ułóż w kolejnościSkładnia formularza z onSubmit w React
  4. Kliknij w kolejnościKolejność: const → { → register,
  5. Zadanie z kodemPraktyka: Formularz logowania z walidacją

Przydatne artykuły