restate / v1.0.0

सिर्फ़ ज़रूरी हिस्से की सदस्यता लें

चुनें कि हर कंपोनेंट स्टोर के किस हिस्से पर निर्भर है, ऑब्जेक्ट की तुलना shallow से करें, बदलावों को batch में समूहित करें और बाहरी इवेंट जोड़ें।

इस पेज परselector देंआज़माएँshallow से कई फ़ील्ड चुननाअपनी तुलनाbatch से बदलाव समूहित करनाReact के बाहर सदस्यताबाहरी इवेंट जोड़ना

selector दें

हुक को एक फ़ंक्शन के साथ कॉल करें जो वही चुने जो कंपोनेंट को चाहिए। हर बदलाव के बाद restate selector चलाता है और परिणाम की तुलना पिछले से Object.is से करता है। अगर दोनों बराबर हैं, तो कंपोनेंट रेंडर नहीं होता।

कार्ड बदलता है। क्या ItemCount रेंडर होता है?

नहीं। उसका selector अब भी उत्पादों की वही संख्या लौटाता है, इसलिए चयन बराबर है और React से रेंडर करने को नहीं कहा जाता।

JavaScript / JSX
const useCart = restate({ items: ['Book'], coupon: '', note: '' });

function ItemCount() {
  // Re-renders only when the number of items changes.
  const count = useCart((cart) => cart.items.length);
  return <p>{count} items</p>;
}

आज़माएँ

फ़ील्ड बदलें और रेंडर काउंटर देखें। हर बार नया ऑब्जेक्ट लौटाने वाला selector देखने के लिए shallow बंद करें।

उदाहरण तैयार हो रहा है…

shallow से कई फ़ील्ड चुनना

जब selector एक ऑब्जेक्ट बनाता है, तो वह हर बार नया लौटाता है, इसलिए Object.is को हमेशा बदलाव दिखता है। दूसरे आर्ग्युमेंट के रूप में shallow दें: वह ऑब्जेक्ट के अपने फ़ील्ड की तुलना एक स्तर गहराई तक करता है।

shallow एक स्तर गहराई तक ऐरे, Map और Set के एलिमेंट की भी तुलना करता है।

JavaScript / JSX
import { restate, shallow } from '@kkwaenggwari/restate';

function CartSummary() {
  const { count, coupon } = useCart(
    (cart) => ({ count: cart.items.length, coupon: cart.coupon }),
    shallow,
  );
  return (
    <p>
      {count} items · {coupon || 'no coupon'}
    </p>
  );
}

अपनी तुलना

दूसरे आर्ग्युमेंट के रूप में कोई भी (left, right) => boolean फ़ंक्शन चलता है। इसे तब इस्तेमाल करें जब shallow काफ़ी न हो, जैसे id से सूची की तुलना करने के लिए।

JavaScript / JSX
const ids = useCart(
  (cart) => cart.items.map((item) => item.id),
  (left, right) => left.length === right.length && left.every((id, index) => id === right[index]),
);

batch से बदलाव समूहित करना

हर set तुरंत सदस्यों को सूचित करता है। जब एक क्रिया कई स्टोर बदलती है, तो उसे batch में लपेटें: मेमोरी तुरंत अपडेट होती है, और सदस्य callback के बाद एक बार चलते हैं।

JavaScript / JSX
import { batch } from '@kkwaenggwari/restate';

function checkout() {
  batch(() => {
    useCart.set((cart) => ({ ...cart, items: [] }));
    useOrder.set((order) => ({ ...order, status: 'paid' }));
  });
  // Subscribers run once, after both stores changed.
}

React के बाहर सदस्यता

subscribeSelector आपको तभी कॉल करता है जब चुना हुआ मान बदले, उसी वैकल्पिक तुलना फ़ंक्शन के साथ।

JavaScript / JSX
const stop = useCart.subscribeSelector(
  (cart) => cart.items.length,
  (count, previous) => analytics.track('cart-size', { count, previous }),
);

बाहरी इवेंट जोड़ना

restate का दूसरा आर्ग्युमेंट updater हो सकता है। वह तब चलता है जब पहला कंपोनेंट या सदस्य सुनना शुरू करे, और उसकी सफ़ाई तब चलती है जब आख़िरी रुके, इसलिए ब्राउज़र इवेंट, सॉकेट या सेंसर तभी तक जुड़े रहते हैं जब तक ज़रूरत हो।

हाथ से नियंत्रण के लिए start() और stop() इस्तेमाल करें।

JavaScript / JSX
import { restate } from '@kkwaenggwari/restate';

// Listens while at least one component or subscriber uses the store.
export const useOnline = restate(true, ({ setState }) => {
  const update = () => setState(navigator.onLine);
  window.addEventListener('online', update);
  window.addEventListener('offline', update);
  update();
  return () => {
    window.removeEventListener('online', update);
    window.removeEventListener('offline', update);
  };
});

दस्तावेज़ खोजें

सभी गाइड के शीर्षक, विवरण और सामग्री में खोजें।