సెలెక్టర్ అనేది స్టేట్ నుండి నిర్దిష్ట డేటాను చదువుకుని (పొందే) ఫంక్షన్. మెమోయిజేషన్ ఒక సెలెక్టర్ యొక్క ఫలితాన్ని క్యాష్ చేస్తుంది కాబట్టి దాని ఇన్పుట్లు మారినప్పుడు మాత్రమే పునర్లెక్కించబడుతుంది — సెలెక్టర్లు ఖరీదైన పనిని చేసినప్పుడు లేదా అనవసర రీ-రెండర్లను నివారించడానికి పనితీరుకు ముఖ్యమైనది.
= state => state.;
= state => state..;
= state =>
state...( sum + i., );
సెలెక్టర్లు స్టేట్ నిర్మాణం గురించిన జ్ఞానాన్ని కేంద్రీకరిస్తాయి — కూర్పులు selectCartTotal(state) ను అడుగుతాయి, అది ఎక్కడ/ఎలా నిల్వ చేయబడుతుందో తెలుసుకోకుండా, కాబట్టి స్టేట్ ఆకారం మారితే మీరు ఒక సెలెక్టర్ను అప్డేట్ చేస్తారు, ప్రతి కూర్పు కాదు.
const selectExpensiveList = state =>
state.items.filter(i => i.active).sort(compareFn); // runs EVERY time, even if items didn't change
పുతiya శ్రేణి/ఆబ్జెక్ట్ను సృష్టించే సెలెక్టర్ ప్రతి కాల్లో కొత్త సూచన ను అందిస్తుంది — ఇది అనవసర రీ-రెండర్లను ట్రిగర్ చేస్తుంది (రియాక్ట్ "కొత్త" విలువను చూస్తుంది) మరియు గణనను వృధా చేస్తుంది.
import { createSelector } from "reselect"; // or RTK's createSelector
const selectActiveSorted = createSelector(
[state => state.items], // input selector(s)
(items) => items.filter(i => i.active).sort(compareFn) // recompute ONLY if items changed
);
createSelector ఫలితాన్ని క్యాష్ చేస్తుంది మరియు దాని ఇన్పుట్లు (state.items) నిజానికి మారినప్పుడు మాత్రమే ఖరీదైన గణనను పునర్నిర్వహిస్తుంది — లేకపోతే ఇది ఒకే సూచన ను అందిస్తుంది, పునర్లెక్కణ మరియు డౌన్స్ట్రీమ్ రీ-రెండర్లను నిరోధిస్తుంది.
const selectTotal = createSelector(
[selectActiveSorted, selectTaxRate], // build on other selectors
(items, rate) => items.reduce((s, i) => s + i.price, 0) * (1 + rate)
);
సెలెక్టర్లు కంపోజ్ చేయబడతాయి, సరళ, వ్యక్తిగతంగా-క్యాష్డ్ భాగాల నుండి సంక్లిష్ట ఉత్పన్నాలను నిర్మిస్తాయి.
సెలెక్టర్లు కూర్పులను స్టేట్ ఆకారం నుండి వేరు చేస్తాయి (నిర్వహణల కోసం ఒక విజయం) మరియు ఉత్పన్న డేటాను వ్యక్తీకరించడానికి ఒక స్థానాన్ని అందిస్తాయి.
మెమోయిజేషన్ ఉత్పన్న సెలెక్టర్లను సమర్థవంతం చేస్తుంది — పునరావృత ఖరీదైన గణన నుండి తప్పించుకుంటుంది మరియు, కీలకంగా, స్థిరమైన సూచనలను అందిస్తుంది కాబట్టి కనెక్ట్ చేయబడిన కూర్పులు అనవసరంగా రీ-రెండర్ కాలేవు.
Redux/NgRx అనువర్తనాలలో, మెమోయిజ్డ్ సెలెక్టర్లు (Reselect/createSelector) పనితీరు మరియు ఆర్కిటెక్చర్ కోసం కీలక సాధనం; ఒకే క్యాషింగ్ ఆలోచన useMemo మరియు computed ఇతర స్థానాల్లో కనిపిస్తుంది.