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:
valuesSubject: Formadagi barcha qiymatlar oqimi.register()orqali bog'langan inputlar o'zgarganda ichki xotira yangilanadi, lekin React komponentini majburiy render qilmaydi.watchSubject:useWatchyokiwatchobunachilariga yangilangan qiymatni yuboradi.stateSubject: Xatolar (errors),isDirty,isValidkabi 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
isDirtyqiymati o'zgarganda komponent qayta render bo'lmaydi. - Formadagi
touchedFieldso'zgarganda komponent qayta render bo'lmaydi. - Faqatgina
errorsobyektiga yangi xato qo'shilsa yoki o'chirilsagina komponent yangilanadi.
[!IMPORTANT] Proxy tuzog'i:
formStatexususiyatlarini doimo render tanasida destructure qiling yoki bevosita o'qing. Agar sizuseEffectyoki submit funksiyasi ichidaginaformState.isDirtyni 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
- Subscription modeli: React Hook Form holatni React daraxtidan tashqaridagi maxsus Subject Store'da saqlaydi va har bir inputni alohida obunachi sifatida boshqaradi.
- Proxy texnologiyasi:
formStateichidagi xususiyatlar faqat kodda chaqirilganidagina obunaga aylanadi, foydalanilmagan xususiyatlar esa komponentni aslo qayta render qilmaydi. - Render Isolation:
useWatchvauseFormStateyordamida dinamik qismlarni (kalkulyatorlar, status nishonlari, jonli hisoblagichlar) alohida komponentlarga ajratish orqali 100+ maydondan iborat ulkan formalarda ham mutlaq silliq foydalanuvchi tajribasiga erishiladi.