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);
  };
});

दस्तऐवजांमध्ये शोधा

सर्व मार्गदर्शकांची शीर्षके, वर्णने आणि मजकुरात शोधा.