चयनकर्ताओं का चयन रद्द करने के लिए कैसे?

Question

मेरे पास एक चयनकर्ता है जो एक सरणी देता है। सरणी में तत्वों ने स्वयं डेटा प्राप्त किया है। मुझे अनिवार्य रूप से एक पुनरावर्ती ज्ञापन चयनकर्ता की आवश्यकता है जो व्युत्पन्न तत्वों से बना एक व्युत्पन्न सरणी देता है।

मेरे वर्तमान प्रयास है:

export const selectEntitesWithAssetBuffers = createSelector(
    [selectSceneEntities, getAssets], 
    (entities, loadedAssets) => { 
    return entities.map((entity) => { 
     entity.buffers = entity.assets.map((assetName) => { 
     return loadedAssets[assetName].arrayBuffer; 
     }) 
     return entity; 
    }) 
    } 
) 

मेरे यहाँ चिंताओं कभी भी entities या loadedAssets परिवर्तन इस पूरी सूची recompute करेंगे। मैं जो सेटअप करने की उम्मीद कर रहा हूं वह selectEntityWithBuffer जैसा कुछ है जो entities.map पर पास हो जाएगा। आदर्श रूप में, मैं चाहता हूं कि यह केवल entity.assets सरणी परिवर्तनों के बाद पुन: गणना करें।

Answer 1

अचयनित करने से आप अपने चयनकर्ताओं को कस्टम समानता परिभाषा प्रदान कर सकते हैं।

import { defaultMemoize, createSelectorCreator } from 'reselect' 

const compareByAssets = (a, b) => { 
    return a.every((element, index) => { 
     return element.assets === b[index].assets 
    }); 
}; 

const createAssetsComparatorSelector = createSelectorCreator(
    defaultMemoize, 
    compareByAssets 
); 

const selectSceneEntitiesByAssetsComparator = createAssetsComparatorSelector((state) => { 
    //however you normally get entities for the pre-existing selectors 
}); 

अब आप उपरोक्त कोड आपके द्वारा दी गई में पिछले selectSceneEntities के स्थान पर इस नई selectSceneEntitiesByAssetsComparator उपयोग कर सकते हैं और यह केवल दोबारा चला जाएगा जब compareByAssets में समानता की जांच विफल रहता है।

assets === assets की सख्त तुलना आपकी आवश्यकताओं को पूरा नहीं करता है तो तुलनित्र फ़ंक्शन को और अद्यतन करने के लिए स्वतंत्र महसूस करें।

Answer 2

आपको जो मिला है उससे गहरी यादें प्राप्त करना एक मुश्किल समस्या है क्योंकि अनावश्यक चयनकर्ताओं को वास्तव में गुजरने वाले तर्कों का समर्थन नहीं करता है। यदि आप अपने चयनकर्ता से एक सरणी लौट रहे हैं, और उस सरणी को बनाने के लिए उपयोग किया गया इनपुट बदल गया है, तो यह इच्छित व्यवहार का तरीका है कि आपको पुनः चयन करने की आवश्यकता होगी। गतिशील तर्कों के लिए the advice in the readme देखें।

Answer 3

अवधारणा के सबूत के रूप में, मैं ऑब्जेक्ट को द्वारा परिणाम फ़ंक्शन पर परिणाम फ़ंक्शन द्वारा प्रदान करने का प्रयास करता हूं।

// Keep a private selector instance 
let cachedSelector; 

export const selectEntitesWithAssetBuffers = function(){ 
    // loadedAssets should be recalculated on each call? 
    const loadedAssets = getAssets(arguments); 

    // create selector on first call 
    if(cachedSelector === undefined) { 
     cachedSelector = createSelector(
      selectSceneEntities, 
      entities => { 
       return entities.map(entity => { 
        entity.buffers = entity.assets.map((assetName) => { 
         return loadedAssets[assetName].arrayBuffer; 
        }) 
        return entity; 
       }) 
      } 
     ) 
    } 

    // Return selector result 
    return cachedSelector(arguments); 
}