restate / v1.0.0
అవసరమైనదానికి మాత్రమే సబ్స్క్రైబ్ చేయండి
ప్రతి కాంపోనెంట్ స్టోర్లోని ఏ భాగంపై ఆధారపడుతుందో ఎంచుకోండి, ఆబ్జెక్ట్లను shallowతో పోల్చండి, మార్పులను batchతో కలపండి, బాహ్య ఈవెంట్లను కనెక్ట్ చేయండి.
ఈ పేజీలో
selector ఇవ్వండిప్రయత్నించండిshallowతో అనేక ఫీల్డ్లను ఎంచుకోవడంకస్టమ్ పోలికbatchతో మార్పులను కలపడంReact బయట సబ్స్క్రిప్షన్బాహ్య ఈవెంట్లను కనెక్ట్ చేయడంselector ఇవ్వండి
కాంపోనెంట్కు అవసరమైనదాన్ని ఎంచుకునే ఫంక్షన్తో హుక్ను కాల్ చేయండి. ప్రతి మార్పు తర్వాత restate selector-ను రన్ చేసి, ఫలితాన్ని మునుపటిదానితో Object.isతో పోలుస్తుంది. రెండూ సమానమైతే కాంపోనెంట్ రెండర్ కాదు.
కార్డ్ మారుతుంది. ItemCount రెండర్ అవుతుందా?
లేదు. దాని selector ఇంకా అదే వస్తువుల సంఖ్యను ఇస్తుంది; ఎంపిక సమానంగా ఉన్నందున React-ను రెండర్ చేయమని అడగరు.
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 ఎలిమెంట్లను కూడా ఒక స్థాయి లోతు వరకు పోలుస్తుంది.
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 ద్వారా జాబితాను పోల్చడానికి, దీన్ని వాడండి.
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 తర్వాత ఒకసారి నడుస్తారు.
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 ఎంచుకున్న విలువ మారినప్పుడే, అదే ఐచ్ఛిక పోలిక ఫంక్షన్తో మిమ్మల్ని కాల్ చేస్తుంది.
const stop = useCart.subscribeSelector(
(cart) => cart.items.length,
(count, previous) => analytics.track('cart-size', { count, previous }),
);బాహ్య ఈవెంట్లను కనెక్ట్ చేయడం
restate రెండవ ఆర్గ్యుమెంట్ ఒక updater కావచ్చు. మొదటి కాంపోనెంట్ లేదా సబ్స్క్రైబర్ వినడం ప్రారంభించినప్పుడు అది నడుస్తుంది; చివరిది ఆగినప్పుడు దాని క్లీనప్ నడుస్తుంది. అందువల్ల బ్రౌజర్ ఈవెంట్లు, సాకెట్లు, సెన్సార్లు అవసరమైనంత సేపు మాత్రమే కనెక్ట్ అయి ఉంటాయి.
మాన్యువల్ నియంత్రణ కోసం start(), stop() వాడండి.
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);
};
});