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