Seriya: React Hook Form Dars 93

useWatch() vs watch() — Performance jihatidan farqlar

useWatch va watch o'rtasidagi asosiy farqlar, render izolyatsiyasi, callback shakli, yon ta'sirlar (side effects) va eng yaxshi tanlov strategiyasi.

93-dars

useWatch() vs watch() — Performance jihatidan farqlar

React Hook Form'da formadagi bir yoki bir nechta maydon qiymatini real vaqt rejimida kuzatish (subscribe bo'lish) uchun ikkita asosiy vosita mavjud: watch() va useWatch().

Tashqi ko'rinishdan ularning vazifasi bir xildek tuyulsa-da, qaysi komponentni qayta render qilishi va ilova unumdorligiga (performance) ko'rsatadigan ta'siri tubdan farq qiladi. Katta formalarda bu farqni bilmaslik ilovaning keskin sekinlashishiga va harf yozishda qotishlarga (typing lag) olib keladi.


1. Asosiy Farq: Render Qamrovi (Scope of Re-render)

Ularning orasidagi eng katta farq — qayta render bo'lish chegarasidir:

  • watch(): O'zi chaqirilgan komponentning o'zini (ko'pincha butun <form> joylashgan ildiz komponentni) va uning ichidagi barcha bolalarini qayta render qiladi.
  • useWatch(): Maxsus hook bo'lib, obunani faqat o'zi chaqirilgan ixcham bola komponent ichida izolyatsiya qiladi. Ota forma va qo'shni maydonlar umuman qayta render bo'lmaydi.
graph TD
  subgraph Variant_Watch["watch() ishlatilganda (Keng qamrovli re-render)"]
    A1["Foydalanuvchi maydonga yozdi"] --> B1["watch('fieldName') ota komponentda"]
    B1 --> C1["Ota Forma to'liq Re-render"]
    C1 --> D1["Input 1, 2, 3... qayta ishga tushadi"]
    C1 --> E1["Barcha ichki komponentlar re-render bo'ladi"]
  end

  subgraph Variant_useWatch["useWatch() ishlatilganda (Izolyatsiya qilingan re-render)"]
    A2["Foydalanuvchi maydonga yozdi"] --> B2["RHF Store ichida qiymat yangilandi"]
    B2 --> C2["Ota Forma: 0 ta re-render (Tinch)"]
    B2 --> D2["Qo'shni inputlar: 0 ta re-render (Tinch)"]
    B2 -->|Faqat obunachi| E2["useWatch chaqirilgan ixcham bola komponent Re-render"]
  end

2. To'liq Taqqoslash Jadvali

Xususiyat watch() useWatch()
Qayta render bo'ladigan joy Hook chaqirilgan ota komponent va barcha bolalari Faqat useWatch() chaqirilgan alohida bola komponent
Argumentsiz chaqirilsa Formadagi har qanday o'zgarishda butun ota formani qayta render qiladi Butun formani kuzatadi, lekin faqat shu kichik bola komponentni render qiladi
Qayerdan olinadi? useForm() hookidan qaytadi Mustaqil hook sifatida react-hook-form dan import qilinadi
control talabi Kerak emas (useForm ichida mavjud) Majburiy: control prop yoki FormProvider orqali beriladi
Side-effect (Callback) rejimi watch((data, { name, type }) => ...) bor (re-render chaqirmaydi) Callback shakli yo'q (faqat reaktiv qiymat qaytaradi)
Tavsiya etiladigan joyi Kichik formalar yoki useEffect ichida callback sifatida O'rta va yirik formalar, hisoblagichlar, prevyu, dinamik bo'limlar

3. Callback shaklidagi watch(): Re-rendersiz yon ta'sirlar

Ko'pchilik dasturchilar bilmaydigan ajoyib xususiyat: watch() funksiyasiga callback berilsa, u hech qanday re-render chaqirmaydi!

useEffect(() => {
  // Callback ko'rinishidagi obuna komponentni qayta render QILMAYDI
  const subscription = watch((value, { name, type }) => {
    console.log("O'zgargan maydon:", name);
    console.log("Joriy form qiymatlari:", value);
    
    // Masalan: Qoralamani localStorage ga avtomatik saqlash
    localStorage.setItem("form_draft", JSON.stringify(value));
  });

  // Komponent unmount bo'lganda obunani tozalash shart
  return () => subscription.unsubscribe();
}, [watch]);

Agar maqsadingiz UI'ni o'zgartirish emas, balki qiymat o'zgarganda API so'rov yuborish, tahliliy voqea (analytics event) jo'natish yoki keshga saqlash bo'lsa — useEffect ichida watch(callback) dan foydalanish eng to'g'ri va tezkor yechimdir.


4. To'liq amaliy misol: useWatch() va watch() integratsiyasi

Quyidagi misolda:

  1. Ota komponentda customerName, address, notes maydonlariga matn yozilganda ota forma ham, xulosa qismi ham qayta render bo'lmaydi.
  2. DiscountSummary komponenti useWatch orqali faqat price va promoCode maydonlariga obuna bo'lgan.
  3. useEffect ichida callback watch() yordamida har bir o'zgarish avtomatik ravishda konsolga va keshga saqlanadi (0 ta re-render bilan):
import React, { useEffect, useRef } from "react";
import {
  useForm,
  useWatch,
  type Control,
  type SubmitHandler,
} from "react-hook-form";

// 1. Form ma'lumotlari tipi
type CheckoutValues = {
  customerName: string;
  address: string;
  notes: string;
  price: number;
  promoCode: string;
};

// Re-render hisoblagich nishoni
function RenderCounter({ label }: { label: string }) {
  const renders = useRef(0);
  renders.current += 1;

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

// 2. useWatch orqali izolyatsiya qilingan chegirma va narx hisoblagich
function DiscountSummary({ control }: { control: Control<CheckoutValues> }) {
  // Faqat 'price' va 'promoCode' o'zgargandagina ushbu bola komponent qayta render bo'ladi
  const [price, promoCode] = useWatch({
    control,
    name: ["price", "promoCode"],
  });

  const safePrice = Number.isFinite(price) && price > 0 ? price : 0;
  const isPromoActive = promoCode?.trim().toUpperCase() === "SAVE20";
  const discountAmount = isPromoActive ? safePrice * 0.2 : 0;
  const finalPrice = safePrice - discountAmount;

  return (
    <div className="border border-indigo-200 bg-indigo-50/50 p-4 rounded-xl space-y-2">
      <div className="flex items-center justify-between border-b border-indigo-100 pb-2">
        <span className="text-xs font-bold text-indigo-950 uppercase tracking-wider">
          To'lov Hisob-kitobi
        </span>
        <RenderCounter label="DiscountSummary" />
      </div>

      <div className="text-sm space-y-1 text-gray-700">
        <div className="flex justify-between">
          <span>Boshlang'ich narx:</span>
          <span>{safePrice.toLocaleString()} so'm</span>
        </div>
        <div className="flex justify-between">
          <span>Chegirma:</span>
          <span className={isPromoActive ? "text-emerald-600 font-semibold" : "text-gray-400"}>
            {isPromoActive ? `-20% (${discountAmount.toLocaleString()} so'm)` : "Mavjud emas"}
          </span>
        </div>
        <div className="flex justify-between font-bold text-base text-gray-900 pt-1 border-t border-indigo-200">
          <span>Jami to'lov:</span>
          <span className="text-indigo-600">{finalPrice.toLocaleString()} so'm</span>
        </div>
      </div>
    </div>
  );
}

// 3. Asosiy Ota Forma
export function UseWatchVsWatchDemo() {
  const {
    register,
    control,
    handleSubmit,
    watch,
    formState: { errors, isSubmitting },
  } = useForm<CheckoutValues>({
    defaultValues: {
      customerName: "",
      address: "",
      notes: "",
      price: 250000,
      promoCode: "",
    },
    mode: "onBlur",
  });

  // 4. watch() callback shakli: Re-rendersiz yon ta'sirlarni kuzatish
  useEffect(() => {
    const subscription = watch((values, { name, type }) => {
      // Bu yerda butun ota forma RE-RENDER BO'LMAYDI
      if (name) {
        console.log(`[Avto-saqlash] Maydon o'zgardi: "${name}" (${type})`);
      }
    });

    return () => subscription.unsubscribe();
  }, [watch]);

  const onSubmit: SubmitHandler<CheckoutValues> = async (data) => {
    console.log("Yakuniy ma'lumotlar:", data);
    await new Promise((r) => setTimeout(r, 600));
    alert("Buyurtma muvaffaqiyatli qabul qilindi!");
  };

  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-lg font-bold text-gray-900">Checkout Formasi</h2>
        <RenderCounter label="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: "Ism majburiy" })}
            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>

        {/* Manzil */}
        <div>
          <label className="block text-sm font-medium text-gray-700 mb-1">
            Yetkazib berish manzili *
          </label>
          <input
            {...register("address", { required: "Manzil majburiy" })}
            placeholder="Toshkent sh., Mirobod tumani..."
            className="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-blue-500 outline-none"
          />
          {errors.address && (
            <p className="text-xs text-rose-500 mt-1">{errors.address.message}</p>
          )}
        </div>

        {/* Izoh */}
        <div>
          <label className="block text-sm font-medium text-gray-700 mb-1">
            Izoh
          </label>
          <input
            {...register("notes")}
            placeholder="Kuryer uchun eslatma"
            className="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-blue-500 outline-none"
          />
        </div>

        {/* Narx va Promo kod */}
        <div className="grid grid-cols-2 gap-3">
          <div>
            <label className="block text-sm font-medium text-gray-700 mb-1">
              Narx (so'm)
            </label>
            <input
              type="number"
              {...register("price", { valueAsNumber: true })}
              className="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-blue-500 outline-none"
            />
          </div>

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

        {/* Izolyatsiya qilingan komponent: faqat price yoki promoCode o'zgarganda render bo'ladi */}
        <DiscountSummary control={control} />

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

5. Qaysi birini qachon tanlash kerak? (Qarorlar Matritsasi)

graph TD
  A["Formadagi qiymatni kuzatish kerak"] --> B{"UI real vaqtda yangilanishi shartmi?"}
  B -->|Yo'q, faqat tugma bosilganda yoki eventda| C["getValues() ishlating (0 ta re-render)"]
  B -->|Ha, UI yangilanishi kerak| D{"O'zgarish qayerda ko'rinadi?"}
  D -->|Alohida kichik qismda (Summary, Badge, Step)| E["useWatch() ishlating (Render Isolation)"]
  D -->|Juda kichik, 1-2 maydonli oddiy formada| F["watch() ishlashi mumkin"]
  B -->|Yo'q, faqat side effect (kesh, tahlil, log)| G["useEffect ichida watch(callback) ishlating"]
  1. useWatch() ni tanlang:
    • Agar narx kalkulyatori, jonli ko'rish (live preview), qadamli forma sarlavhasi yoki shartli blok kabi UI elementlarini yangilash kerak bo'lsa.
    • Formalarda 5 tadan ortiq maydon bo'lsa.
  2. watch(callback) ni tanlang:
    • Agar forma qiymatlari o'zgarganda localStorage ga saqlash, debounce bilan serverga qoralama yuborish yoki analytika qayd etish kerak bo'lsa.
  3. getValues() ni tanlang:
    • Agar qiymat foydalanuvchi klaviaturada yozayotgan lahzada ekranda ko'rinishi shart bo'lmasa (masalan, faqat submit yoki maxsus tugma bosilganda o'qilsa yetarli).
  4. watch() (qiymat qaytaruvchi) dan qachon qochish kerak:
    • Ota formada const val = watch("field") deb yozishdan iloji boricha saqlaning, chunki u butun formaning tezligini pasaytiradi.

Xulosa

  • Render miqyosi: watch() butun ota komponentni qayta render qiladi; useWatch() esa o'zgarishni faqat chaqirilgan ixcham bola komponent ichida ushlab qoladi.
  • Unumdorlik: Yirik va murakkab loyihalarda har doim useWatch() afzal ko'riladi.
  • Callback qulayligi: Faqat yon ta'sirlarni kuzatish uchun useEffect ichida watch((val) => ...) obunasi eng samarali usuldir, chunki u 0 ta re-render bilan ishlaydi.