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

డాక్యుమెంటేషన్‌లో వెతకండి

అన్ని గైడ్‌ల శీర్షికలు, వివరణలు, విషయంలో వెతకండి.