React experimental_useSubscription: प्रदर्शन प्रभाव को समझना और कम करना

React का experimental_useSubscription हुक आपके कंपोनेंट्स के भीतर बाहरी डेटा स्रोतों की सदस्यता लेने का एक शक्तिशाली और घोषणात्मक तरीका प्रदान करता है। यह डेटा फ़ेचिंग और प्रबंधन को काफी सरल बना सकता है, खासकर जब रीयल-टाइम डेटा या जटिल स्टेट के साथ काम कर रहे हों। हालाँकि, किसी भी शक्तिशाली टूल की तरह, इसके साथ संभावित प्रदर्शन प्रभाव भी आते हैं। प्रदर्शनकारी React एप्लिकेशन बनाने के लिए इन प्रभावों को समझना और उचित अनुकूलन तकनीकों को अपनाना महत्वपूर्ण है।

experimental_useSubscription क्या है?

experimental_useSubscription, जो वर्तमान में React के प्रायोगिक APIs का हिस्सा है, कंपोनेंट्स को बाहरी डेटा स्टोर्स (जैसे Redux स्टोर्स, Zustand, या कस्टम डेटा स्रोत) की सदस्यता लेने और डेटा बदलने पर स्वचालित रूप से फिर से रेंडर करने के लिए एक तंत्र प्रदान करता है। यह मैन्युअल सब्सक्रिप्शन प्रबंधन की आवश्यकता को समाप्त करता है और डेटा सिंक्रनाइज़ेशन के लिए एक स्वच्छ, अधिक घोषणात्मक दृष्टिकोण प्रदान करता है। इसे अपने कंपोनेंट्स को लगातार अपडेट होने वाली जानकारी से सहजता से जोड़ने के लिए एक समर्पित टूल के रूप में सोचें।

यह हुक दो प्राथमिक तर्क लेता है:

• dataSource: एक ऑब्जेक्ट जिसमें एक subscribe मेथड (जैसा कि आप ऑब्जर्वेबल लाइब्रेरी में पाते हैं) और एक getSnapshot मेथड होता है। subscribe मेथड एक कॉलबैक लेता है जिसे डेटा स्रोत बदलने पर लागू किया जाएगा। getSnapshot मेथड डेटा का वर्तमान मान लौटाता है।
• getSnapshot (वैकल्पिक): एक फ़ंक्शन जो आपके कंपोनेंट को डेटा स्रोत से आवश्यक विशिष्ट डेटा निकालता है। यह अनावश्यक री-रेंडर को रोकने के लिए महत्वपूर्ण है जब समग्र डेटा स्रोत बदलता है, लेकिन कंपोनेंट द्वारा आवश्यक विशिष्ट डेटा वही रहता है।

यहां एक काल्पनिक डेटा स्रोत के साथ इसके उपयोग को प्रदर्शित करने वाला एक सरलीकृत उदाहरण दिया गया है:

import { experimental_useSubscription as useSubscription } from 'react';

const myDataSource = {
  subscribe(callback) {
    // डेटा परिवर्तनों की सदस्यता लेने का लॉजिक (जैसे, WebSockets, RxJS, आदि का उपयोग करके)
    // उदाहरण: setInterval(() => callback(), 1000); // हर सेकंड बदलाव का अनुकरण करें
  },
  getSnapshot() {
    // स्रोत से वर्तमान डेटा प्राप्त करने का लॉजिक
    return myData;
  }
};

function MyComponent() {
  const data = useSubscription(myDataSource);

  return (
    <div>
      <p>Data: {data}</p>
    </div>
  );
}

सब्सक्रिप्शन प्रोसेसिंग ओवरहेड: मूल मुद्दा

experimental_useSubscription के साथ प्राथमिक प्रदर्शन चिंता सब्सक्रिप्शन प्रोसेसिंग से जुड़े ओवरहेड से उत्पन्न होती है। हर बार जब डेटा स्रोत बदलता है, तो subscribe मेथड के माध्यम से पंजीकृत कॉलबैक लागू होता है। यह हुक का उपयोग करके कंपोनेंट का री-रेंडर ट्रिगर करता है, जो संभावित रूप से एप्लिकेशन की जवाबदेही और समग्र प्रदर्शन को प्रभावित कर सकता है। यह ओवरहेड कई तरीकों से प्रकट हो सकता है:

• बढ़ी हुई रेंडरिंग आवृत्ति: सब्सक्रिप्शन, अपनी प्रकृति के अनुसार, लगातार री-रेंडर का कारण बन सकते हैं, खासकर जब अंतर्निहित डेटा स्रोत तेजी से अपडेट होता है। एक स्टॉक टिकर कंपोनेंट पर विचार करें - लगातार मूल्य में उतार-चढ़ाव लगभग-लगातार री-रेंडर में बदल जाएगा।
• अनावश्यक री-रेंडर: भले ही किसी विशिष्ट कंपोनेंट से संबंधित डेटा नहीं बदला हो, एक साधारण सब्सक्रिप्शन अभी भी एक री-रेंडर को ट्रिगर कर सकता है, जिससे व्यर्थ गणना होती है।
• बैच अपडेट की जटिलता: जबकि React री-रेंडर को कम करने के लिए अपडेट को बैच करने का प्रयास करता है, सब्सक्रिप्शन की अतुल्यकालिक प्रकृति कभी-कभी इस अनुकूलन में हस्तक्षेप कर सकती है, जिससे अपेक्षा से अधिक व्यक्तिगत री-रेंडर होते हैं।

प्रदर्शन बाधाओं की पहचान करना

अनुकूलन रणनीतियों में गोता लगाने से पहले, experimental_useSubscription से संबंधित संभावित प्रदर्शन बाधाओं की पहचान करना आवश्यक है। यहां बताया गया है कि आप इस दृष्टिकोण को कैसे अपना सकते हैं:

1. रिएक्ट प्रोफाइलर

React प्रोफाइलर, जो React DevTools में उपलब्ध है, प्रदर्शन बाधाओं की पहचान करने के लिए आपका प्राथमिक उपकरण है। इसका उपयोग करें:

• कंपोनेंट इंटरैक्शन रिकॉर्ड करें: अपने एप्लिकेशन को प्रोफाइल करें जब यह सक्रिय रूप से experimental_useSubscription के साथ कंपोनेंट्स का उपयोग कर रहा हो।
• रेंडर समय का विश्लेषण करें: उन कंपोनेंट्स की पहचान करें जो बार-बार रेंडर हो रहे हैं या रेंडर होने में लंबा समय ले रहे हैं।
• री-रेंडर के स्रोत की पहचान करें: प्रोफाइलर अक्सर उन विशिष्ट डेटा स्रोत अपडेट को इंगित कर सकता है जो अनावश्यक री-रेंडर को ट्रिगर कर रहे हैं।

उन कंपोनेंट्स पर पूरा ध्यान दें जो डेटा स्रोत में बदलाव के कारण बार-बार री-रेंडर हो रहे हैं। यह देखने के लिए ड्रिल डाउन करें कि क्या री-रेंडर वास्तव में आवश्यक हैं (यानी, यदि कंपोनेंट के प्रॉप्स या स्टेट में महत्वपूर्ण बदलाव हुआ है)।

2. प्रदर्शन निगरानी उपकरण

उत्पादन वातावरण के लिए, प्रदर्शन निगरानी उपकरणों (जैसे, Sentry, New Relic, Datadog) का उपयोग करने पर विचार करें। ये उपकरण निम्नलिखित में अंतर्दृष्टि प्रदान कर सकते हैं:

• वास्तविक दुनिया के प्रदर्शन मेट्रिक्स: कंपोनेंट रेंडर समय, इंटरैक्शन लेटेंसी और समग्र एप्लिकेशन जवाबदेही जैसे मेट्रिक्स को ट्रैक करें।
• धीमे कंपोनेंट्स की पहचान करें: उन कंपोनेंट्स को इंगित करें जो वास्तविक दुनिया के परिदृश्यों में लगातार खराब प्रदर्शन कर रहे हैं।
• उपयोगकर्ता अनुभव पर प्रभाव: समझें कि प्रदर्शन संबंधी समस्याएं उपयोगकर्ता अनुभव को कैसे प्रभावित करती हैं, जैसे धीमी लोडिंग समय या अनुत्तरदायी इंटरैक्शन।

3. कोड समीक्षा और स्टेटिक विश्लेषण

कोड समीक्षा के दौरान, इस बात पर पूरा ध्यान दें कि experimental_useSubscription का उपयोग कैसे किया जा रहा है:

• सब्सक्रिप्शन स्कोप का आकलन करें: क्या कंपोनेंट्स बहुत व्यापक डेटा स्रोतों की सदस्यता ले रहे हैं, जिससे अनावश्यक री-रेंडर हो रहे हैं?
• getSnapshot कार्यान्वयन की समीक्षा करें: क्या getSnapshot फ़ंक्शन कुशलता से आवश्यक डेटा निकाल रहा है?
• संभावित रेस कंडीशंस की तलाश करें: सुनिश्चित करें कि अतुल्यकालिक डेटा स्रोत अपडेट सही ढंग से संभाले जाते हैं, खासकर जब समवर्ती रेंडरिंग के साथ काम कर रहे हों।

स्टेटिक विश्लेषण उपकरण (जैसे, उपयुक्त प्लगइन्स के साथ ESLint) आपके कोड में संभावित प्रदर्शन समस्याओं की पहचान करने में भी मदद कर सकते हैं, जैसे useCallback या useMemo हुक में छूटी हुई निर्भरताएँ।

अनुकूलन रणनीतियाँ: प्रदर्शन प्रभाव को कम करना

एक बार जब आप संभावित प्रदर्शन बाधाओं की पहचान कर लेते हैं, तो आप experimental_useSubscription के प्रभाव को कम करने के लिए कई अनुकूलन रणनीतियों को अपना सकते हैं।

1. getSnapshot के साथ चयनात्मक डेटा फ़ेचिंग

सबसे महत्वपूर्ण अनुकूलन तकनीक getSnapshot फ़ंक्शन का उपयोग करके केवल कंपोनेंट द्वारा आवश्यक विशिष्ट डेटा निकालना है। यह अनावश्यक री-रेंडर को रोकने के लिए महत्वपूर्ण है। पूरे डेटा स्रोत की सदस्यता लेने के बजाय, केवल डेटा के प्रासंगिक सबसेट की सदस्यता लें।

उदाहरण:

मान लीजिए आपके पास उपयोगकर्ता की जानकारी का प्रतिनिधित्व करने वाला एक डेटा स्रोत है, जिसमें नाम, ईमेल और प्रोफ़ाइल चित्र शामिल हैं। यदि किसी कंपोनेंट को केवल उपयोगकर्ता का नाम प्रदर्शित करने की आवश्यकता है, तो getSnapshot फ़ंक्शन को केवल नाम निकालना चाहिए:

const userDataSource = {
  subscribe(callback) { /* ... */ },
  getSnapshot() {
    return {
      name: "Alice Smith",
      email: "alice.smith@example.com",
      profilePicture: "/images/alice.jpg"
    };
  }
};

function NameComponent() {
  const name = useSubscription(userDataSource, () => userDataSource.getSnapshot().name);

  return <p>User Name: {name}</p>;
}

इस उदाहरण में, NameComponent केवल तभी री-रेंडर होगा जब उपयोगकर्ता का नाम बदलता है, भले ही userDataSource ऑब्जेक्ट में अन्य गुण अपडेट किए गए हों।

2. useMemo और useCallback के साथ मेमोइज़ेशन

मेमोइज़ेशन React कंपोनेंट्स को अनुकूलित करने के लिए एक शक्तिशाली तकनीक है जो महंगी गणनाओं या फ़ंक्शंस के परिणामों को कैश करके काम करती है। getSnapshot फ़ंक्शन के परिणाम को मेमोइज़ करने के लिए useMemo का उपयोग करें, और subscribe मेथड को पास किए गए कॉलबैक को मेमोइज़ करने के लिए useCallback का उपयोग करें।

उदाहरण:

import { experimental_useSubscription as useSubscription } from 'react';
import { useCallback, useMemo } from 'react';

const myDataSource = {
  subscribe(callback) { /* ... */ },
  getSnapshot() {
    // महंगी डेटा प्रोसेसिंग लॉजिक
    return processData(myData);
  }
};

function MyComponent({ prop1, prop2 }) {
  const getSnapshot = useCallback(() => {
    return myDataSource.getSnapshot();
  }, []);

  const data = useSubscription(myDataSource, getSnapshot);

  const memoizedValue = useMemo(() => {
    // डेटा के आधार पर महंगी गणना
    return calculateValue(data, prop1, prop2);
  }, [data, prop1, prop2]);

  return <div>{memoizedValue}</div>;
}

getSnapshot फ़ंक्शन और परिकलित मान को मेमोइज़ करके, आप अनावश्यक री-रेंडर और महंगी गणनाओं को रोक सकते हैं जब निर्भरताएँ नहीं बदली हों। यह सुनिश्चित करें कि आप useCallback और useMemo के निर्भरता सरणियों में प्रासंगिक निर्भरताएँ शामिल करें ताकि यह सुनिश्चित हो सके कि मेमोइज़ किए गए मान आवश्यकता पड़ने पर सही ढंग से अपडेट किए गए हैं।

3. डिबाउंसिंग और थ्रॉटलिंग

तेजी से अपडेट होने वाले डेटा स्रोतों (जैसे, सेंसर डेटा, रीयल-टाइम फ़ीड) के साथ काम करते समय, डिबाउंसिंग और थ्रॉटलिंग री-रेंडर की आवृत्ति को कम करने में मदद कर सकते हैं।

• डिबाउंसिंग: अंतिम अपडेट के बाद एक निश्चित समय बीत जाने तक कॉलबैक के आह्वान में देरी करता है। यह तब उपयोगी होता है जब आपको केवल निष्क्रियता की अवधि के बाद नवीनतम मान की आवश्यकता होती है।
• थ्रॉटलिंग: एक निश्चित समय अवधि के भीतर कॉलबैक को कितनी बार लागू किया जा सकता है, इसकी संख्या को सीमित करता है। यह तब उपयोगी होता है जब आपको UI को समय-समय पर अपडेट करने की आवश्यकता होती है, लेकिन जरूरी नहीं कि डेटा स्रोत से हर अपडेट पर हो।

आप Lodash जैसी लाइब्रेरी या setTimeout का उपयोग करके कस्टम कार्यान्वयन के साथ डिबाउंसिंग और थ्रॉटलिंग लागू कर सकते हैं।

उदाहरण (थ्रॉटलिंग):

import { experimental_useSubscription as useSubscription } from 'react';
import { useRef, useCallback } from 'react';

function MyComponent() {
  const lastUpdate = useRef(0);

  const throttledGetSnapshot = useCallback(() => {
    const now = Date.now();
    if (now - lastUpdate.current > 100) { // अधिकतम हर 100ms में अपडेट करें
      lastUpdate.current = now;
      return myDataSource.getSnapshot();
    }
    return null; // या एक डिफ़ॉल्ट मान
  }, []);

  const data = useSubscription(myDataSource, throttledGetSnapshot);

  return <div>{data}</div>;
}

यह उदाहरण सुनिश्चित करता है कि getSnapshot फ़ंक्शन को अधिकतम हर 100 मिलीसेकंड में कॉल किया जाता है, जिससे डेटा स्रोत तेजी से अपडेट होने पर अत्यधिक री-रेंडर को रोका जा सके।

4. React.memo का लाभ उठाना

React.memo एक उच्च-क्रम का कंपोनेंट है जो एक कार्यात्मक कंपोनेंट को मेमोइज़ करता है। experimental_useSubscription का उपयोग करने वाले कंपोनेंट को React.memo के साथ लपेटकर, आप री-रेंडर को रोक सकते हैं यदि कंपोनेंट के प्रॉप्स नहीं बदले हैं।

उदाहरण:

import React, { experimental_useSubscription as useSubscription, memo } from 'react';

function MyComponent({ prop1, prop2 }) {
  const data = useSubscription(myDataSource);

  return <div>{data}, {prop1}, {prop2}</div>;
}

export default memo(MyComponent, (prevProps, nextProps) => {
  // कस्टम तुलना लॉजिक (वैकल्पिक)
  return prevProps.prop1 === nextProps.prop1 && prevProps.prop2 === nextProps.prop2;
});

इस उदाहरण में, MyComponent केवल तभी री-रेंडर होगा जब prop1 या prop2 बदलता है, भले ही useSubscription से डेटा अपडेट हो। आप कंपोनेंट को कब री-रेंडर करना चाहिए, इस पर अधिक बारीक नियंत्रण के लिए React.memo को एक कस्टम तुलना फ़ंक्शन प्रदान कर सकते हैं।

5. अपरिवर्तनीयता और संरचनात्मक साझाकरण

जटिल डेटा संरचनाओं के साथ काम करते समय, अपरिवर्तनीय डेटा संरचनाओं का उपयोग प्रदर्शन में काफी सुधार कर सकता है। अपरिवर्तनीय डेटा संरचनाएं यह सुनिश्चित करती हैं कि कोई भी संशोधन एक नया ऑब्जेक्ट बनाता है, जिससे परिवर्तनों का पता लगाना और केवल आवश्यक होने पर री-रेंडर को ट्रिगर करना आसान हो जाता है। Immutable.js या Immer जैसी लाइब्रेरी आपको React में अपरिवर्तनीय डेटा संरचनाओं के साथ काम करने में मदद कर सकती हैं।

संरचनात्मक साझाकरण, एक संबंधित अवधारणा, डेटा संरचना के उन हिस्सों का पुन: उपयोग करना शामिल है जो नहीं बदले हैं। यह नए अपरिवर्तनीय ऑब्जेक्ट बनाने के ओवरहेड को और कम कर सकता है।

6. बैच अपडेट और शेड्यूलिंग

React का बैच अपडेट तंत्र स्वचालित रूप से कई स्टेट अपडेट को एक ही री-रेंडर चक्र में समूहित करता है। हालाँकि, अतुल्यकालिक अपडेट (जैसे कि सब्सक्रिप्शन द्वारा ट्रिगर किए गए) कभी-कभी इस तंत्र को बायपास कर सकते हैं। सुनिश्चित करें कि आपके डेटा स्रोत अपडेट requestAnimationFrame या setTimeout जैसी तकनीकों का उपयोग करके उचित रूप से शेड्यूल किए गए हैं ताकि React को प्रभावी ढंग से अपडेट बैच करने की अनुमति मिल सके।

उदाहरण:

const myDataSource = {
  subscribe(callback) {
    setInterval(() => {
      requestAnimationFrame(() => {
        callback(); // अगले एनीमेशन फ्रेम के लिए अपडेट शेड्यूल करें
      });
    }, 100);
  },
  getSnapshot() { /* ... */ }
};

7. बड़े डेटासेट के लिए वर्चुअलाइजेशन

यदि आप बड़े डेटासेट प्रदर्शित कर रहे हैं जो सब्सक्रिप्शन के माध्यम से अपडेट किए जाते हैं (जैसे, आइटम की एक लंबी सूची), तो वर्चुअलाइजेशन तकनीकों (जैसे, react-window या react-virtualized जैसी लाइब्रेरी) का उपयोग करने पर विचार करें। वर्चुअलाइजेशन केवल डेटासेट के दृश्यमान हिस्से को रेंडर करता है, जिससे रेंडरिंग ओवरहेड में काफी कमी आती है। जैसे ही उपयोगकर्ता स्क्रॉल करता है, दृश्यमान भाग गतिशील रूप से अपडेट होता है।

8. डेटा स्रोत अपडेट को कम करना

शायद सबसे सीधा अनुकूलन डेटा स्रोत से ही अपडेट की आवृत्ति और दायरे को कम करना है। इसमें शामिल हो सकता है:

• अपडेट आवृत्ति को कम करना: यदि संभव हो, तो उस आवृत्ति को कम करें जिस पर डेटा स्रोत अपडेट पुश करता है।
• डेटा स्रोत लॉजिक को अनुकूलित करना: सुनिश्चित करें कि डेटा स्रोत केवल आवश्यक होने पर अपडेट हो रहा है और अपडेट यथासंभव कुशल हैं।
• सर्वर-साइड पर अपडेट फ़िल्टर करना: केवल क्लाइंट को वे अपडेट भेजें जो वर्तमान उपयोगकर्ता या एप्लिकेशन स्टेट के लिए प्रासंगिक हैं।

9. Redux या अन्य स्टेट मैनेजमेंट लाइब्रेरी के साथ सिलेक्टर्स का उपयोग करना

यदि आप Redux (या अन्य स्टेट मैनेजमेंट लाइब्रेरी) के साथ experimental_useSubscription का उपयोग कर रहे हैं, तो सुनिश्चित करें कि आप सिलेक्टर्स का प्रभावी ढंग से उपयोग करें। सिलेक्टर्स शुद्ध फ़ंक्शन होते हैं जो वैश्विक स्टेट से डेटा के विशिष्ट टुकड़े प्राप्त करते हैं। यह आपके कंपोनेंट्स को केवल उस डेटा की सदस्यता लेने की अनुमति देता है जिसकी उन्हें आवश्यकता है, जब स्टेट के अन्य हिस्से बदलते हैं तो अनावश्यक री-रेंडर को रोकते हैं।

उदाहरण (Reselect के साथ Redux):

import { useSelector } from 'react-redux';
import { createSelector } from 'reselect';

// उपयोगकर्ता नाम निकालने के लिए सिलेक्टर
const selectUserName = createSelector(
  state => state.user,
  user => user.name
);

function NameComponent() {
  // useSelector और सिलेक्टर का उपयोग करके केवल उपयोगकर्ता नाम की सदस्यता लें
  const userName = useSelector(selectUserName);

  return <p>User Name: {userName}</p>;
}

एक सिलेक्टर का उपयोग करके, NameComponent केवल तभी री-रेंडर होगा जब Redux स्टोर में user.name गुण बदलता है, भले ही user ऑब्जेक्ट के अन्य हिस्से अपडेट किए गए हों।

सर्वोत्तम प्रथाएं और विचार

• बेंचमार्क और प्रोफाइल: अनुकूलन तकनीकों को लागू करने से पहले और बाद में हमेशा अपने एप्लिकेशन का बेंचमार्क और प्रोफाइल करें। यह आपको यह सत्यापित करने में मदद करता है कि आपके परिवर्तन वास्तव में प्रदर्शन में सुधार कर रहे हैं।
• प्रगतिशील अनुकूलन: सबसे प्रभावशाली अनुकूलन तकनीकों (जैसे, getSnapshot के साथ चयनात्मक डेटा फ़ेचिंग) से शुरू करें और फिर आवश्यकतानुसार अन्य तकनीकों को उत्तरोत्तर लागू करें।
• विकल्पों पर विचार करें: कुछ मामलों में, experimental_useSubscription का उपयोग करना सबसे अच्छा समाधान नहीं हो सकता है। वैकल्पिक दृष्टिकोणों का अन्वेषण करें, जैसे कि पारंपरिक डेटा फ़ेचिंग तकनीकों या अंतर्निहित सब्सक्रिप्शन तंत्र के साथ स्टेट मैनेजमेंट लाइब्रेरी का उपयोग करना।
• अपडेट रहें: experimental_useSubscription एक प्रायोगिक API है, इसलिए इसका व्यवहार और API React के भविष्य के संस्करणों में बदल सकता है। नवीनतम React दस्तावेज़ीकरण और सामुदायिक चर्चाओं से अपडेट रहें।
• कोड स्प्लिटिंग: बड़े अनुप्रयोगों के लिए, प्रारंभिक लोड समय को कम करने और समग्र प्रदर्शन में सुधार के लिए कोड स्प्लिटिंग पर विचार करें। इसमें आपके एप्लिकेशन को छोटे-छोटे टुकड़ों में तोड़ना शामिल है जो मांग पर लोड होते हैं।

निष्कर्ष

experimental_useSubscription React में बाहरी डेटा स्रोतों की सदस्यता लेने का एक शक्तिशाली और सुविधाजनक तरीका प्रदान करता है। हालाँकि, संभावित प्रदर्शन प्रभावों को समझना और उचित अनुकूलन रणनीतियों को अपनाना महत्वपूर्ण है। चयनात्मक डेटा फ़ेचिंग, मेमोइज़ेशन, डिबाउंसिंग, थ्रॉटलिंग और अन्य तकनीकों का उपयोग करके, आप सब्सक्रिप्शन प्रोसेसिंग ओवरहेड को कम कर सकते हैं और प्रदर्शनकारी React एप्लिकेशन बना सकते हैं जो रीयल-टाइम डेटा और जटिल स्टेट को कुशलता से संभालते हैं। यह सुनिश्चित करने के लिए अपने एप्लिकेशन का बेंचमार्क और प्रोफाइल करना याद रखें कि आपके अनुकूलन प्रयास वास्तव में प्रदर्शन में सुधार कर रहे हैं। और जैसे-जैसे experimental_useSubscription विकसित होता है, हमेशा React दस्तावेज़ीकरण पर अपडेट के लिए नज़र रखें। diligent प्रदर्शन निगरानी के साथ सावधानीपूर्वक योजना बनाकर, आप एप्लिकेशन की जवाबदेही का त्याग किए बिना experimental_useSubscription की शक्ति का उपयोग कर सकते हैं।