Series: React Hook Form Lesson 91

Subscription-based Architecture — RHF subscription mexanizmi

React Hook Form'ning obuna (subscription) mexanizmi, Proxy-based formState, useWatch izolyatsiyasi va keraksiz re-renderlarning oldini olish.

91-dars

Subscription-based Architecture — RHF subscription mexanizmi

Subscription-based Architecture (obuna asosidagi arxitektura) deganda React Hook Form'ning butun formani bitta ulkan monolit state sifatida emas, balki obunalar (subscriptions) tizimi orqali boshqarishi tushuniladi.

Har bir input maydoni, useWatch hooki yoki formState faqat o'ziga bevosita tegishli bo'lgan o'zgarishlargagina obuna bo'ladi (subscribe). Natijada biror maydon qiymati o'zgarganda butun forma daraxti qayta render bo'lmasdan, faqat o'sha o'zgargan qiymatga bog'liq bo'lgan ixcham komponentlargina yangilanadi.


1. An'anaviy State vs Subscription Store

Oddiy React formalarida (useState) bitta inputga harf kiritilsa, ota komponent holati yangilanadi va butun forma komponenti qayta ishga tushadi:

graph TD
  subgraph Ananaviy_useState["An'anaviy useState (Global Re-render)"]
    A1["Foydalanuvchi inputga yozdi"] --> B1["setState(newValue)"]
    B1 --> C1["Ota Forma Komponenti Re-render"]
    C1 --> D1["Input 1 Re-render"]
    C1 --> E1["Input 2 Re-render"]
    C1 --> F1["Input 30... Re-render"]
  end

  subgraph RHF_Subscription["React Hook Form (Subscription Store)"]
    A2["Foydalanuvchi inputga yozdi"] --> B2["DOM Event / Ref Update"]
    B2 --> C2["RHF Internal Subject Store"]
    C2 -->|Ota forma re-render BO'LMAYDI| D2["Ota Forma (Tinch)"]
    C2 -->|Faqat obunachi yangilanadi| E2["useWatch / LivePreview Re-render"]
  end
Xususiyat An'anaviy useState / Formik React Hook Form (Subscription)
State saqlanish joyi React komponentining o'zida RHF control ichidagi markaziy subject store
Klaviatura bosilishi Har bir tugma butun formani qayta render qiladi Input darajasida DOM ref yangilanadi (0 ta re-render)
Bog'liq maydonlar Ota component re-renderi orqali hisoblanadi useWatch orqali izolyatsiya qilingan obunachi render bo'ladi
Holat monitoringi Barcha state propertylar doim to'liq tekshiriladi Proxy orqali faqat o'qilgan (accessed) maydonlar kuzatiladi
Katta formalarda unumdorlik 30+ maydonda sekinlashuv va qotishlar seziladi 100+ maydonda ham 60 FPS silliq tezlik ta'minlanadi

2. RHF ning ichki Subject va Observer mexanizmi

React Hook Form ichida RxJS uslubidagi soddalashtirilgan Observer / Subject mexanizmi mavjud. U control._subjects obyekti ostida joylashgan:

  1. values Subject: Formadagi barcha qiymatlar oqimi. register() orqali bog'langan inputlar o'zgarganda ichki xotira yangilanadi, lekin React komponentini majburiy render qilmaydi.
  2. watch Subject: useWatch yoki watch obunachilariga yangilangan qiymatni yuboradi.
  3. state Subject: Xatolar (errors), isDirty, isValid kabi meta-holatlar o'zgarganda xabar beradi.

Faqatgina ma'lum bir field yoki holatni tinglayotgan komponentgina observer.next() chaqiruvini qabul qilib, o'zining ichki React holatini yangilaydi.


3. formState va Proxy-based Obuna tizimi

React Hook Form unumdorlikni oshirish uchun JavaScript Proxy obyektidan foydalanadi:

const {
  register,
  formState: { errors }, // <-- Proxy faqat `errors` o'qilganini qayd etadi
} = useForm<FormValues>();

Agar siz formState dan faqat errors ni o'qisangiz:

  • Formadagi isDirty qiymati o'zgarganda komponent qayta render bo'lmaydi.
  • Formadagi touchedFields o'zgarganda komponent qayta render bo'lmaydi.
  • Faqatgina errors obyektiga yangi xato qo'shilsa yoki o'chirilsagina komponent yangilanadi.

[!IMPORTANT] Proxy tuzog'i: formState xususiyatlarini doimo render tanasida destructure qiling yoki bevosita o'qing. Agar siz useEffect yoki submit funksiyasi ichidagina formState.isDirty ni tekshirsangiz, React Hook Form uni render bosqichida o'qilgan deb hisoblamasligi va tegishli obunani ulamasligi mumkin.


4. Render Isolation: useWatch va useFormState

Subscription arxitekturasining eng katta kuchi — bu Render Isolation (renderlarni cheklash va izolyatsiya qilish) hisoblanadi.

Noto'g'ri yondashuv (Anti-pattern):

function BadCheckoutForm() {
  const { register, watch } = useForm();
  // Butun ota forma har bir klaviatura bosilishida qayta render bo'ladi!
  const coupon = watch("couponCode");

  return (
    <form>
      <input {...register("customerName")} />
      <input {...register("couponCode")} />
      <p>Kupon: {coupon}</p>
    </form>
  );
}

To'g'ri yondashuv (Subscription Isolation):

// Alohida ixcham komponent
function LiveCouponBadge({ control }: { control: Control<CheckoutFormValues> }) {
  // Faqat couponCode o'zgarganda shu kichik komponent re-render bo'ladi!
  const coupon = useWatch({ control, name: "couponCode" });
  return <p>Kupon: {coupon}</p>;
}

function GoodCheckoutForm() {
  const { register, control } = useForm<CheckoutFormValues>();
  // Ota forma umuman re-render bo'lmaydi!
  return (
    <form>
      <input {...register("customerName")} />
      <input {...register("couponCode")} />
      <LiveCouponBadge control={control} />
    </form>
  );
}

5. To'liq amaliy misol: Checkout formasi va izolyatsiya qilingan obunachilar

Quyidagi to'liq TypeScript misolida ota forma render bo'lishdan to'liq himoyalangan, har bir qism (LiveCouponPreview, ShippingCostBadge, FormStatusFooter) faqat o'z obunalariga ko'ra mustaqil yangilanadi:

import React, { useRef } from "react";
import {
  useForm,
  useWatch,
  useFormState,
  type Control,
  type SubmitHandler,
} from "react-hook-form";

// 1. Form ma'lumotlari tipi
type CheckoutFormValues = {
  customerName: string;
  email: string;
  couponCode: string;
  shippingMethod: "standard" | "express" | "pickup";
  note: string;
};

// Yordamchi komponent: Re-renderlar sonini vizual ko'rsatish
function RenderCounter({ name }: { name: string }) {
  const renderCount = useRef(0);
  renderCount.current += 1;

  return (
    <span className="text-xs px-2 py-0.5 rounded bg-gray-100 text-gray-700 font-mono">
      {name} render: {renderCount.current}
    </span>
  );
}

// 2. Izolyatsiya qilingan Obunachi: Kupon kodi holati
function LiveCouponPreview({ control }: { control: Control<CheckoutFormValues> }) {
  const couponCode = useWatch({
    control,
    name: "couponCode",
  });

  const normalized = couponCode?.trim().toUpperCase() || "";
  const isPromoValid = normalized === "REACT2026";

  return (
    <div className="border border-dashed border-indigo-300 bg-indigo-50/50 p-3 rounded-lg space-y-1">
      <div className="flex items-center justify-between">
        <span className="text-xs font-semibold text-indigo-900 uppercase tracking-wide">
          Kupon Holati
        </span>
        <RenderCounter name="LiveCouponPreview" />
      </div>
      <p className="text-sm font-medium">
        {!normalized ? (
          <span className="text-gray-500">Kupon kiritilmagan</span>
        ) : isPromoValid ? (
          <span className="text-emerald-700 font-semibold">
            ✓ {normalized} — 15% chegirma muvaffaqiyatli qo'llandi!
          </span>
        ) : (
          <span className="text-rose-600 font-medium">
            ✗ {normalized} — Bunday promokod mavjud emas
          </span>
        )}
      </p>
    </div>
  );
}

// 3. Izolyatsiya qilingan Obunachi: Yetkazib berish narxi
function ShippingCostBadge({ control }: { control: Control<CheckoutFormValues> }) {
  const shipping = useWatch({
    control,
    name: "shippingMethod",
  });

  const costs = {
    pickup: "0 so'm (Olib ketish)",
    standard: "25 000 so'm (1-2 kun)",
    express: "45 000 so'm (2 soat ichida)",
  };

  return (
    <div className="flex items-center justify-between text-sm py-1">
      <span className="text-gray-600">Yetkazib berish: <strong>{costs[shipping]}</strong></span>
      <RenderCounter name="ShippingBadge" />
    </div>
  );
}

// 4. Izolyatsiya qilingan FormState Obunachisi: Submit holati va tugma
function FormStatusFooter({ control }: { control: Control<CheckoutFormValues> }) {
  // useFormState orqali faqat isDirty, isValid va isSubmitting ga obuna bo'lamiz
  const { isDirty, isSubmitting } = useFormState({
    control,
  });

  return (
    <div className="pt-4 border-t flex items-center justify-between">
      <div className="text-xs text-gray-500 flex items-center gap-2">
        <span>Forma o'zgargan: {isDirty ? "Ha (isDirty)" : "Yo'q"}</span>
        <RenderCounter name="Footer" />
      </div>

      <button
        type="submit"
        disabled={isSubmitting}
        className="px-5 py-2.5 bg-blue-600 hover:bg-blue-700 disabled:bg-gray-400 text-white font-medium rounded-lg transition"
      >
        {isSubmitting ? "Yuborilmoqda..." : "Buyurtmani tasdiqlash"}
      </button>
    </div>
  );
}

// 5. Asosiy Ota Forma Komponenti
export function SubscriptionArchitectureExample() {
  const {
    register,
    control,
    handleSubmit,
    formState: { errors },
  } = useForm<CheckoutFormValues>({
    defaultValues: {
      customerName: "",
      email: "",
      couponCode: "",
      shippingMethod: "standard",
      note: "",
    },
    mode: "onBlur",
  });

  const onSubmit: SubmitHandler<CheckoutFormValues> = async (data) => {
    // Simulyatsiya qilingan API so'rov
    await new Promise((resolve) => setTimeout(resolve, 1000));
    console.log("Muvaffaqiyatli yuborildi:", data);
  };

  return (
    <div className="max-w-xl mx-auto p-6 bg-white rounded-xl shadow-md space-y-6">
      <div className="flex items-center justify-between border-b pb-3">
        <h2 className="text-xl font-bold text-gray-900">Buyurtmani rasmiylashtirish</h2>
        <RenderCounter name="Ota Forma" />
      </div>

      <form onSubmit={handleSubmit(onSubmit)} className="space-y-4">
        {/* Mijoz ismi */}
        <div>
          <label className="block text-sm font-medium text-gray-700 mb-1">
            Mijoz ismi *
          </label>
          <input
            {...register("customerName", { required: "Ismingizni kiriting" })}
            placeholder="Masalan: Sardorbek"
            className="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-blue-500 outline-none"
          />
          {errors.customerName && (
            <p className="text-xs text-rose-500 mt-1">{errors.customerName.message}</p>
          )}
        </div>

        {/* Email */}
        <div>
          <label className="block text-sm font-medium text-gray-700 mb-1">
            Email manzil *
          </label>
          <input
            type="email"
            {...register("email", {
              required: "Email kiritish shart",
              pattern: {
                value: /^[^@\s]+@[^@\s]+\.[^@\s]+$/,
                message: "Email formati noto'g'ri",
              },
            })}
            placeholder="[email protected]"
            className="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-blue-500 outline-none"
          />
          {errors.email && (
            <p className="text-xs text-rose-500 mt-1">{errors.email.message}</p>
          )}
        </div>

        {/* Yetkazib berish turi */}
        <div>
          <label className="block text-sm font-medium text-gray-700 mb-1">
            Yetkazib berish usuli
          </label>
          <select
            {...register("shippingMethod")}
            className="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-blue-500 outline-none bg-white"
          >
            <option value="standard">Oddiy yetkazib berish (Standart)</option>
            <option value="express">Tezkor kuryer (Express)</option>
            <option value="pickup">Do'kondan olib ketish (Self-pickup)</option>
          </select>
          <ShippingCostBadge control={control} />
        </div>

        {/* Kupon kodi */}
        <div>
          <label className="block text-sm font-medium text-gray-700 mb-1">
            Chegirma kuponi
          </label>
          <input
            {...register("couponCode")}
            placeholder="Masalan: REACT2026"
            className="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-blue-500 outline-none uppercase font-mono"
          />
        </div>

        {/* Izolyatsiya qilingan kupon holati */}
        <LiveCouponPreview control={control} />

        {/* Izoh */}
        <div>
          <label className="block text-sm font-medium text-gray-700 mb-1">
            Qo'shimcha izoh
          </label>
          <textarea
            {...register("note")}
            rows={2}
            placeholder="Kuryer uchun qavat, eshik kodi va boshqa eslatmalar..."
            className="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-blue-500 outline-none"
          />
        </div>

        {/* Izolyatsiya qilingan footer va tugma */}
        <FormStatusFooter control={control} />
      </form>
    </div>
  );
}

6. Keng tarqalgan xatolar va Best Practices

1. Argumentsiz watch() dan saqlaning

Ota komponent ichida const allValues = watch(); chaqirish subscription arxitekturasining afzalligini yo'qqa chiqaradi — chunki u ota komponentni formadagi istalgan maydon o'zgarishiga qayta render qiladigan qilib qo'yadi. Agar butun forma qiymati faqat submit vaqtida kerak bo'lsa, handleSubmit((data) => ...) yetarli, unumdorlik uchun watch() kerak emas.

2. control ni to'g'ri ulash

useWatch yoki useFormState ishlatganda, doimo o'sha komponentga control obyektini prop sifatida bering yoki komponent FormProvider tegi ostida o'ralgan bo'lsin. Aks holda hook qaysi formaga obuna bo'lish kerakligini bila olmaydi.

3. Render bosqichida formState o'qish

formState xususiyatlari (masalan, errors, isValid, isDirty) Proxy getter orqali kuzatiladi. Shuning uchun ularni JSX render qilinayotgan tanada o'qish tavsiya qilinadi:

// YAXSHI: Proxy obunani render paytida darhol ro'yxatga oladi
const { isDirty, isValid } = formState;

// TAVSIYA ETILMAYDI: Renderda o'qilmagan bo'lsa, faqat callback ichida obuna tushmay qolishi mumkin
const handleCancel = () => {
  if (formState.isDirty) { ... }
};

Xulosa

  1. Subscription modeli: React Hook Form holatni React daraxtidan tashqaridagi maxsus Subject Store'da saqlaydi va har bir inputni alohida obunachi sifatida boshqaradi.
  2. Proxy texnologiyasi: formState ichidagi xususiyatlar faqat kodda chaqirilganidagina obunaga aylanadi, foydalanilmagan xususiyatlar esa komponentni aslo qayta render qilmaydi.
  3. Render Isolation: useWatch va useFormState yordamida dinamik qismlarni (kalkulyatorlar, status nishonlari, jonli hisoblagichlar) alohida komponentlarga ajratish orqali 100+ maydondan iborat ulkan formalarda ham mutlaq silliq foydalanuvchi tajribasiga erishiladi.