Redux कम करने निर्भर राज्य के स्लाइस

Question

मैं Redux में कम करने रचना की अवधारणा का आनंद लें, लेकिन के लिए/राज्य आकार डिजाइन एक परिदृश्य में जहाँ मैं की तरह एक कम करने को विभाजित करने के हैं में चलाने की है, लेकिन बच्चों reducers तो भरोसा होगा दूसरों के राज्य परिवर्तनों को अपने परिवर्तन करने के लिए।

उदाहरण

मेरे राज्य में के लिए, मैं निम्नलिखित का ट्रैक रखने की जरूरत है:

• संभव रैंकों (यानी [ 2, 3, 4, 5, 6 ])
• वर्तमान में चयनित रैंक की एक श्रेणी (उपरोक्त मानों में से एक)।
• पर आधारित रैंक पर निर्भर करता है, संभावित प्रशिक्षण स्तर की एक श्रृंखला।

  function rankAndTraining(state = { 
      selectedRank   : 4, 
      availableRanks   : [ 2, 3, 4, 5, 6 ], 
      availableTrainingLevels : [ 1, 2, 3 ], 
      selectedTrainingLevel : 2, 
  }, action) { 
      . 
      . 
      . 
      case SELECT_RANK: 
  
       let newRank = action.rank; 
  
       if(!availableRanks.contains(newRank)) { 
       // If new rank is not an allowed value, do nothing. 
       return state; 
       } 
  
       // Update selectedRank with newRank... 
  
       // Update availableTrainingLevels array based on newRank... 
       // [ 1 ... (selectedRank - 1) ] 
  
       // Update selectedTrainingLevel if it is now out of range 
       // of availableTrainingLevel (i.e. set to highest value of new range) 
  
       return state; 
      . 
      . 
      . 
  } 
  

  : रिश्ता है कि सीमा से [ 1 .. (selectedRank - 1) ]

• एक वर्तमान में चयनित प्रशिक्षण स्तर सीमा के भीतर ऊपर

शुरू में चला जाता है, मैं एक बड़ा कम करने जो इन पहलुओं के सभी समझाया था मैं इस reducer को विभाजित करना चाहता था, क्योंकि मुझे लगा कि रैंक और प्रशिक्षण स्तर अलग-अलग reducers में बनाए रखा जा सकता है।

हालांकि, वहाँ इस तरह के रूप में राज्य के टुकड़े है कि अभी भी नियंत्रित किया जा सकता है अगर कम करने विभाजित किया गया था की आवश्यकता होगी भर निर्भरता, कर रहे हैं:

• नई श्रेणी अमान्य (पूर्व है यदि यह में नहीं है। उपलब्ध रैंक), तो प्रशिक्षण स्तर बिट्स को अद्यतन नहीं किया जाना चाहिए।

अगर मैं एक और कम करने में प्रशिक्षण के स्तर बिट्स विभाजित करने के लिए थे, तो वे कोई रास्ता नहीं इस "रैंक जाँच" का नतीजा पता करने के लिए, के लिए होता है सब के बाद से वे अपने राज्य टुकड़ा में "देख" होगा प्रशिक्षण स्तर टुकड़े है।

इस परिदृश्य में, उपर्युक्त रेड्यूसर वास्तव में उन राज्यों का "सबसे छोटा टुकड़ा" है जो मैं प्राप्त कर सकता हूं, उनके बीच निर्भरताओं को देखते हुए? या क्या इसे विभाजित करने का एक बेहतर तरीका है जिसे मैं नहीं देख सकता हूं?

Answer 1

आप का उपयोग करते हैं Redux मिडलवेयर thunk आप पहली बार पूरे राज्य निरीक्षण कर सकते हैं इससे पहले कि आप वास्तव में अपने कार्रवाई भेजने की पूरी तरह से अपना कार्रवाई प्रेषण के बजाय और फिर सशर्त कम करने में अपनी स्थिति को अपडेट:

function selectRankIfAllowed() { 
    return (dispatch, getState) => { 
    const { availableRanks } = getState(); 

    if(!availableRanks.contains(newRank)) { 
     // If new rank is not an allowed value, do nothing. 
     return state; 
    } 

    dispatch(selectRank()); 
    }; 
} 

https://github.com/gaearon/redux-thunk