Redux: मैं createStore में इनिशियलस्टेट देता हूं और फिर कॉम्बिनेशन रेड्यूसर दिखाते हैं कि मेरा एक रेड्यूसर इनिशियलाइज़ेशन के दौरान अपरिभाषित लौटा है

यह एक बग ट्रैकर है, सपोर्ट सिस्टम नहीं। उपयोग संबंधी प्रश्नों के लिए, कृपया स्टैक ओवरफ़्लो या रिएक्टिफ्लक्स का उपयोग करें। धन्यवाद!

मुझे एक ही समस्या है।

कदम:

1. छवि साधारण स्टोर आकार { foo, bar } ।
2. simpleReducer = state => state जैसे सरल रेड्यूसर बनाएं।
3. reducers = combineReducers({ foo: simpleReducer, bar: simpleReducer }) में रेड्यूसर को मिलाएं।
4. createState(reducers, { foo: Obj1, bar: Obj2 }) साथ प्रारंभिक मूल्य के साथ राज्य बनाएं।
5. त्रुटि प्राप्त करें Reducer "foo" returned undefined during initialization. If the state passed to the reducer is undefined, you must explicitly return the initial state

कारण assertReducerShape जो प्रारंभिक राज्य भागों को प्राप्त करने के लिए अपरिभाषित स्थिति वाले सभी रेड्यूसर चलाते हैं । मेरा सरल रेड्यूसर अपना तर्क देता है जो उस मामले में अपरिभाषित है। क्यों Obj1 से createState कॉल को फू-पार्ट की प्रारंभिक स्थिति के रूप में नहीं माना जाता है?

@timdorr क्या आप इस मुद्दे को फिर से खोल सकते हैं?

समाधान simpleReducer = (state = null) => state । लेकिन क्या यह ठीक है?

combineReducers , प्रत्येक स्लाइस रेड्यूसर से राज्य के अपने स्लाइस "स्वामित्व" की अपेक्षा की जाती है। इसका मतलब है कि यदि वर्तमान टुकड़ा अपरिभाषित है, तो प्रारंभिक मूल्य प्रदान करना, और यदि आप ऐसा नहीं कर रहे हैं तो combineReducers इंगित करेगा।

'प्रारंभिक अवस्था' के कई अर्थ हैं। वे रेड्यूसर का डिफ़ॉल्ट रिटर्न मान और createStore का दूसरा तर्क हैं। मुझे लगता है कि एक समस्या है। क्या आप बता सकते हैं कि कंबाइनरेड्यूसर इनिशियलस्टेट और क्रिएटस्टेट के लिए रिड्यूसर की जांच क्यों नहीं करते हैं?

@Vittly : combineReducers को जानबूझकर सोचा गया है, जबकि createStore ऐसा नहीं है। createStore बस जो भी रूट रेड्यूसर फ़ंक्शन आपने दिया है उसे कॉल करता है, और परिणाम बचाता है। combineReducers मानता है कि यदि आप इसका उपयोग कर रहे हैं, तो आप इस बारे में मान्यताओं के एक विशिष्ट सेट में खरीद रहे हैं कि राज्य को कैसे व्यवस्थित किया जाना चाहिए और संयुक्त रेड्यूसर को कैसे व्यवहार करना चाहिए।

आप #191 और #1189 के माध्यम से पढ़ना चाह सकते हैं, जो इतिहास और विवरण में जाते हैं कि combineReducers को क्यों माना जाता है और इसकी क्या राय है।

तो मुद्दा यह है (शीघ्र ही) "यदि आप रेड्यूसर को जोड़ते हैं तो आप अपने स्टोर ट्री को भी विभाजित करते हैं और आप कुछ याद कर सकते हैं या जानबूझकर स्टोर के केवल एक हिस्से को createStore 2nd arg में प्रीलोड कर सकते हैं। स्टोर ट्री को अधिक सुसंगत उपयोग करने के लिए assertReducerShape"। ठीक है, रेफरी के लिए धन्यवाद

यहां भी यही समस्या।
तो मैं createStore उपयोग करता हूं और प्रारंभिक स्थिति पास करता हूं। लेकिन reduct.js फ़ाइल में, फ़ंक्शन assertReducerShape रेडक्स undefined स्थिति पास करते समय मेरे रेड्यूसर की जांच करेगा।

आईएमएचओ यह एक बग है।

@JoseFMP : मैं प्रभावी रूप से गारंटी

ज़रूर। मैंने स्टैक ओवरफ्लो में समस्या में एक मुद्दा दायर किया:
https://stackoverflow.com/questions/53018766/why-redux-reducer-getting-undefined-instead-of-the-initial-state

मामला काफी सीधा है। तो अगर मैं स्टोर बनाते समय एक प्रारंभिक स्थिति निर्धारित करता हूं ... रेडक्स रेड्यूसर का मूल्यांकन undefined राज्य के साथ क्यों करना चाहता है? यह वास्तव में सभी रेड्यूसर को एक नया राज्य undefined वापस करने के लिए बनाता है।

लेकिन बकवास है, क्योंकि हम एक प्रारंभिक अवस्था से गुजरते हैं।
तो यह विफल हो रहा है:

import { combineReducers, createStore } from 'redux';

const configReducer = (config: any, action: any): any =>{
        return config;
}

const customData = (customData: any, action: any): any =>  {
        return customData;
}
const reducers = combineReducers({config: configReducer, customData: customDataReducer})

const defaultConfig = "cool config";
const data = "yieaah some data";

var initialState = {config: defaultConfig, customData: data};
const store = createStore(reducers, initialState) // at this point redux calls all the reducers with 'undefined' state. Why?

@ जोसएफएमपी :

आह, मुझे लगता है कि मुझे पता है कि मामला क्या है। यह विशिष्ट है कि combineReducers() काम करता है।

combineReducers उम्मीद करता है कि आपके द्वारा दिए गए सभी "स्लाइस रेड्यूसर" कुछ नियमों का पालन करेंगे। विशेष रूप से, यह अपेक्षा करता है कि _if_ आपके रेड्यूसर को state === undefined साथ बुलाया जाता है, यह एक उपयुक्त डिफ़ॉल्ट मान लौटाएगा। इसे सत्यापित करने के लिए, combineReducers() वास्तव में आपके रेड्यूसर को (undefined, {type : "SOME_RANDOMIZED_ACTION_TYPE"}) यह देखने के लिए कॉल करेगा कि यह अपरिभाषित या "वास्तविक" मान देता है या नहीं।

आपके रेड्यूसर वर्तमान में जो कुछ भी पारित किया गया है उसे वापस करने के अलावा कुछ भी नहीं करते हैं। इसका मतलब है कि यदि state अपरिभाषित है, तो वे _return_ अपरिभाषित होंगे। तो, combineReducers() आपको बता रहा है कि आप उस परिणाम को तोड़ रहे हैं जिसकी वह अपेक्षा करता है।

बस घोषणाओं को configReducer = (config = {}, action) , आदि जैसे कुछ में बदलें, और इससे चेतावनियां ठीक हो जाएंगी।

फिर से, स्पष्ट होने के लिए: यह _not_ एक बग है। यह व्यवहार सत्यापन है।

हेज @markerikson आपकी प्रतिक्रिया के लिए धन्यवाद।
कुछ टिप्पणियाँ:

1) नहीं, यह विशिष्ट नहीं है combineReducers । अगर मैं combineReducers उपयोग नहीं करता और अपना खुद का रूट रेड्यूसर लागू नहीं करता, तो वही होता है।

2) यहां असंगतता यह है कि, Redux प्रलेखन में यह उल्लेख किया गया है कि यदि रेड्यूसर को ऐसी स्थिति के साथ बुलाया जाता है जो अज्ञात या अप्रत्याशित है, तो उसे स्थिति को संशोधित नहीं करना चाहिए और तर्क के रूप में आए मान को वापस नहीं करना चाहिए। यानी ... अगर यह प्राप्त करता है undefined यह तो लौटना चाहिए undefined । लेकिन एक अन्य नियम कहता है कि रेड्यूसर को कभी भी undefined वापस नहीं करना चाहिए, इसलिए ये दो नियम, जैसा कि वर्तमान में रेडक्स प्रलेखन में हैं, असंगत हैं। और कार्यान्वयन के साथ असंगत।

@JoseFMP : जैसा कि मैंने पहले कहा था, यदि आप एक कोडसैंडबॉक्स प्रदान कर सकते हैं जो विशेष रूप से इस मुद्दे को प्रदर्शित करता है, टिप्पणियों के साथ यह इंगित करता है कि आप वास्तव में क्या होने की उम्मीद करते हैं, वास्तव में क्या हो रहा है, तो मैं शायद एक नज़र डाल सकता हूं। (साथ ही, कृपया उन दस्तावेज़ अनुभागों को इंगित करें जो आपको असंगत लगते हैं।) तब तक, मैं इसे केवल इस गलतफहमी के लिए तैयार कर सकता हूं कि Redux आंतरिक रूप से कैसे काम करता है।

धन्यवाद @markerikson ।
दस्तावेज़ीकरण के बारे में:

तो अगर रेड्यूसर को अज्ञात कार्रवाई के साथ बुलाया जाता है, तो मुझे उसी स्थिति को वापस करना चाहिए क्योंकि रेड्यूसर को नहीं पता कि इस रेड्यूसर में कार्रवाई क्या करनी चाहिए।

स्टोर बनाते समय, Redux एक अज्ञात क्रिया और पिछली स्थिति undefined भेजकर रेड्यूसर की जाँच करता है। इसलिए यदि पिछला राज्य undefined , तो दस्तावेज़ के अनुसार रेड्यूसर को undefined वापस करना चाहिए (क्योंकि रेड्यूसर कार्रवाई को नहीं जानता है)। लेकिन अगर रेड्यूसर undefined लौटाता है, तो मैं आपको गारंटी देता हूं कि कोई रेडक्स ऐप काम नहीं कर सका।

उदाहरण कोड के लिए:

import { createStore } from 'redux';

const configReducer = (config: any, action: any): any =>{
        return config;
}

const customReducer = (customData: any, action: any): any =>  {
        return customData;
}

const reducers = (currentState: IAppState, action: any): IAppState => {

    var appStateToEvaluate: any;
    if (currentState) { //needs to add this to pass the `undefined` check of redux
        appStateToEvaluate = currentState;
    }
    else{
        //why redux is doing this ?!
        appStateToEvaluate = {}
    }
    const newState: IAppState = {
        cvConfig: configReducer(appStateToEvaluate.config, action),
        personalData: customReducer(appStateToEvaluate.customData, action)
    }

    return newState;
}

const defaultConfig = "cool config";
const data = "yieaah some data";

var initialState = {config: defaultConfig, customData: data};
const store = createStore(reducers, initialState) // at this point redux calls all the reducers with 'undefined' state. Why?

@JoseFMP : मुझे लगता है कि आप यहां जो महत्वपूर्ण अंतर खो रहे हैं वह यह है कि उस उदाहरण में, रेड्यूसर फ़ंक्शन ने _already_ उस मामले को संभाला है जहां state undefined , ES6 डिफ़ॉल्ट तर्क वाक्यविन्यास का उपयोग करके:

function todoApp(state = initialState, action) {

तो ट्यूटोरियल में सलाह सही है - एक रेड्यूसर _चाहिए_ हमेशा मौजूदा स्थिति लौटाता है, _यह मानते हुए कि अपरिभाषित मामला पहले ही संभाला जा चुका है_।

@markerikson
आपके उत्तर के लिए धन्यवाद।
यह मेरे लिए स्पष्ट है। ट्यूटोरियल में बस गायब है। ट्यूटोरियल में यह नहीं कहा गया है कि वापसी का मामला रिड्यूसर में डिफ़ॉल्ट पैरामीटर मान के रूप में निर्दिष्ट है। अतः आपने जो वाक्य इटैलिक किया है वह सही है। वह है वह। मेरी चिंता यह है कि यह ट्यूटोरियल में गायब है। या मुझे यह नहीं मिला, या अस्पष्ट है।

अब, ट्यूटोरियल और/या दस्तावेज़ीकरण से स्वतंत्र रूप से, मुझे यह undefined व्यक्तिगत रूप से उस विशिष्ट मामले के लिए समझ में नहीं आता है जिसमें प्रारंभिक स्थिति निर्दिष्ट है। यदि कोई प्रारंभिक स्थिति निर्दिष्ट नहीं है तो मुझे लगता है कि यह ठीक है। अब यह कोई चर्चा नहीं है, केवल मेरी राय है: यदि एक प्रारंभिक स्थिति निर्दिष्ट की जाती है तो मुझे यह जांच करने के लिए व्यर्थ लगता है। लेकिन मैं वैसे भी इसके साथ रह सकता हूं (और करना होगा);)

आपके समर्थन मार्क के लिए धन्यवाद।

हम निश्चित रूप से अपने बड़े डॉक्स सुधार (#2590 ) के हिस्से के रूप में कुछ वाक्यांशों को फिर से लिखने का प्रयास कर सकते हैं।

उस ने कहा, रेडक्स के पीछे मूल विचारों में से एक यह था कि प्रत्येक "स्लाइस रेड्यूसर" राज्य के अपने टुकड़े "स्वामित्व" के लिए ज़िम्मेदार है, जिसमें दोनों अपडेट और प्रारंभिक मूल्य प्रदान करना शामिल है। आप "अच्छी तरह से, मैं createStore लिए एक प्रारंभिक मूल्य प्रदान कर रहा हूं" के पहलू पर अटका हुआ प्रतीत होता है, लेकिन आप उम्मीदों को छूट दे रहे हैं कि Redux को यह कैसे व्यवहार करना चाहिए, भले ही आप _aren't_ अलग से मूल्य प्रदान करना।

कुछ हद तक आश्चर्य हुआ कि मैंने इसे अभी तक लिंक नहीं किया है, लेकिन हो सकता है कि आप दस्तावेज़ों में प्रारंभिक राज्य पृष्ठ के माध्यम से पढ़ना चाहें।

@markerikson
हाँ आप सही हैं। मैं पहले से ही प्रारंभिक स्थिति के बारे में दस्तावेज जानता हूं। मेरा क्या मतलब है (और मुझे विश्वास है कि यही कारण है कि यह मुद्दा बनाया गया था और लोग भी इस दिशा में थे) यह है कि स्टोर बनाते समय "प्रारंभिक स्थिति" प्रदान करना और अभी भी "डिफ़ॉल्ट स्थिति" को परिभाषित करना काउंटर-सहज ज्ञान युक्त है। स्लाइस रिड्यूसर (या रूट रिड्यूसर)। यानी क्योंकि बहुत बार, लेकिन जरूरी नहीं कि वे समान हों, या बहुत संबंधित हों, उन्हें दो बार परिभाषित करने के लिए काउंटर-सहज ज्ञान युक्त लगता है। एक exapmple के रूप में देखें @ElonXun की पोस्ट या @Vittly जो मुझे के रूप में ही भ्रमित हो गया। यानी मेरी टिप्पणी Redux की API नहीं है, यह इस बारे में है कि विशुद्ध रूप से मानवीय दृष्टिकोण से, इस विशेष परिदृश्य में Redux के API का उपयोग करना कितना सहज महसूस करता है।

ध्यान दें कि रेडक्स के एपीआई का उपयोग करते समय अंतिम पैराग्राफ मानवीय भावना के बारे में है। मशीनरी कार्यान्वयन या इसके पीछे के कारण पूरी तरह से वैध हो सकते हैं। लेकिन एक एपीआई उपभोक्ता के रूप में यह भ्रमित करने वाला लगता है।

उदाहरण के लिए, मेरे लिए, विकास करते समय मेरे आवेदन में अक्सर प्रारंभिक स्थिति होती है। तो आमतौर पर मुझे इसे दो बार टाइप करने की आवश्यकता होती है। एक बार जब मैं स्टोर बनाता हूं तो इसे प्लग करने के लिए और दूसरी बार इसे स्लाइस रेड्यूसर में डिफ़ॉल्ट मान के रूप में वितरित करने के लिए। बेशक उसके लिए कई उपाय। लेकिन सिद्धांत यह है कि मानव के रूप में मेरे लिए यह भ्रमित करता है कि मुझे एक ही चीज़ को दो बार टाइप करना होगा।

हालाँकि मुझे लगता है कि एक विशेष मामला है जिसमें प्रारंभिक स्थिति निर्धारित है और यह अनिवार्य नहीं है कि स्लाइस रिड्यूसर या रूट रिड्यूसर में "डिफ़ॉल्ट स्थिति" है, जो अभी भी इसे अनिवार्य बनाने की तुलना में अधिक परेशानी है।

तो यहां केवल यह उल्लेख करना है कि यह थोड़ा सा सहज ज्ञान युक्त लगता है। लेकिन बस यही।

मुझे पहले के संस्करणों में combineReducers को assertReducerShape कॉल करना याद नहीं है। मेरे कोड में undefined मेरे रेड्यूसर की अमान्य स्थिति है। मेरे लिए यह सुनिश्चित करने के लिए मुझे CombReducers की आवश्यकता नहीं है, मुझे इसे "रिड्यूसर को संयोजित करने" की आवश्यकता है और यदि कुछ बदलता है तो रूट ऑब्जेक्ट को फिर से बनाएं। यह मेरी अपेक्षा से थोड़ा आगे जा रहा है। आईएमओ, अब यह भी राय है।

माना जाता है कि मैंने कुछ समय में कंबाइन रेड्यूसर का उपयोग नहीं किया है क्योंकि मुझे मूल एप्लिकेशन में इसकी आवश्यकता नहीं है जिसे मैं विकसित कर रहा हूं। लेकिन अब मैं उस एप्लिकेशन को लपेटने की कोशिश कर रहा हूं, और लगा कि गठबंधन रेड्यूसर एप्लिकेशन को टुकड़ा करने के लिए उपयोग करने के लिए ठीक था। assertReducerShape का व्यवहार आश्चर्यजनक है।

@lukescott : वह चेक सितंबर 2015 से है:

https://github.com/reduxjs/redux/commit/a1485f0e30ea0ea5e023a6d0f5947bd56edff7dd

और हाँ, combineReducers() _जानबूझकर_ माना जाता है। यदि आप उन चेतावनियों को नहीं चाहते हैं, तो उन चेकों के बिना अपना समान फ़ंक्शन लिखना काफी आसान है।

एक विशिष्ट उदाहरण के रूप में, Dan's Gist Redux को चेक के बिना 100 पंक्तियों में देखें।

मैं समझ गया। पुराने संस्करण ने प्रारंभिक स्थिति को पारित किया और प्रत्येक रन पर अपरिभाषित के लिए जाँच की (यदि मुझे याद है)। आश्चर्य की बात यह है कि प्रारंभिक अवस्था को पहली बार में पारित नहीं किया जाता है। अपरिभाषित पास करना मेरे ऐप में एक त्रुटि है। जैसा कि मैंने कहा, मैं इस परियोजना पर कुछ समय से काम कर रहा हूं, और कुछ समय के लिए कंबाइन रेड्यूसर का उपयोग नहीं किया है। मैं अभी इसका उपयोग करने में वापस आ रहा हूं, हमारे आवेदन को एक रैपर के अंदर रखकर।

मुझे यह भी लगता है कि यह माना जाता है। लेकिन वह राय थी "एक रेड्यूसर को अपरिभाषित नहीं लौटना चाहिए" - वह नियम है जिसका मैं पालन करता हूं। यह बदल गया है "हम अपरिभाषित हो जाएंगे और आपको कुछ भी नहीं से स्वयं राज्य बनाना होगा"। CombReducers अब "हमेशा एक प्रारंभिक अवस्था होती है" के साथ काम नहीं करता है - जो दुर्भाग्यपूर्ण है। इससे 3 साल पहले बने नियमों में भारी बदलाव आया है।

मुझे सच में यकीन नहीं है कि आप किस व्यवहार में बदलाव का जिक्र कर रहे हैं। क्या आप विशिष्ट उदाहरणों की ओर इशारा कर सकते हैं?

इनिशियलाइज़िंग स्टेट डॉक्स पेज preloadedState तर्क के बीच createStore , एक रेड्यूसर के लिए state = initialState हैंडलिंग और combineReducers() बीच की बातचीत को बताता है। यह स्टैक ओवरफ्लो उत्तर पर आधारित है जिसे डैन ने 2016 की शुरुआत में लिखा था, और उस संबंध में कुछ भी सार्थक नहीं बदला है जिसके बारे में मुझे पता है।

@markerikson आप सही कह रहे हैं। मैंने पीछे मुड़कर 2.0 तक देखा, और ऐसा लगता है कि इसने हमेशा ऐसा किया है। शायद मेरे आवेदन की जटिलता ने इसे और अधिक स्पष्ट कर दिया है।

मेरे पास मुद्दा यह है कि मेरे रेड्यूसर को इस प्रकार परिभाषित किया गया है:

reducer(state: State, action: Action)

मतलब कि राज्य अपरिभाषित नहीं होना चाहिए। इसका मतलब है कि एक प्रारंभिक अवस्था होनी चाहिए। लेकिन क्योंकि CombReducers इसे जांचने के लिए रेड्यूसर (अपरिभाषित, आईएनआईटी) को कॉल करता है, यह मेरे कोड में एक त्रुटि का कारण बनता है (यदि यह सफल होता है तो बाद में इसे रेड्यूसर (इनिटस्टेट, आईएनआईटी) - आईएनआईटी को दो बार कॉल करना)।

इसका मतलब यह है कि कंबाइन रेड्यूसर में उपयोग किए जाने वाले किसी भी रेड्यूसर को इस प्रकार परिभाषित किया जाना चाहिए:

reducer(state: State | undefined, action: Action)

तो मेरा यह दावा गलत है कि उसने पहले ऐसा नहीं किया। लेकिन मेरे पास जो मुद्दा है, और ओपी के पास, वही होने की संभावना है: यह आपको अपने रेड्यूसर को वैकल्पिक राज्य के साथ घोषित करने के लिए मजबूर करता है। मुझे वास्तव में चेतावनियां नहीं मिलती हैं, इससे मेरा कोड क्रैश हो जाता है क्योंकि यह एक गैर-अपरिभाषित स्थिति की अपेक्षा करता है।

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

हां। जैसा कि उस दस्तावेज़ पृष्ठ में वर्णित है, जब आप combineReducers , तो अपेक्षा विशेष रूप से यह है कि प्रत्येक स्लाइस रेड्यूसर अपनी प्रारंभिक स्थिति को वापस करने के लिए ज़िम्मेदार है, और इसे sliceReducer(undefined, action) जवाब में ऐसा करना चाहिए। combineReducers के बिंदु से, आपका कोड _is_ छोटी गाड़ी है क्योंकि यह अपेक्षित अनुबंध का पालन नहीं कर रहा है, और इसलिए यह आपको बता रहा है कि कोड गलत है।

क्या आप वास्तव में प्रारंभिक स्थिति प्रदान नहीं कर रहे हैं? कोड वास्तव में कैसा दिखता है?

मैं createStore के माध्यम से प्रारंभिक स्थिति प्रदान कर रहा हूं। लेकिन उस प्रारंभिक स्थिति को मेरे रेड्यूसर को पास नहीं किया जा रहा है क्योंकि assertReducerShape स्पष्ट रूप से मेरे रेड्यूसर को undefined साथ कॉल कर रहा है, मेरे द्वारा प्रारंभिक अवस्था पास करने के बावजूद:

https://github.com/reduxjs/redux/blob/231f0b32641059caab3f98a3e04d3afad19a7d1/src/combineReducers.js#L68

मेरा कोड छोटी गाड़ी नहीं है। इसके लिए केवल यह आवश्यक है कि अपरिभाषित इसमें _never_ पारित हो। एक प्रारंभिक स्थिति की आवश्यकता है और सर्वर से उत्पन्न होता है। CombReducers बस उस अनुबंध को तोड़ता है और एक आवश्यक राज्य के साथ सख्ती से रिड्यूसर टाइप करना असंभव बनाता है। मैं इसे कम्बाइनरेडर्स के बिना कर सकता हूं और यह ठीक काम करता है। मुझे लगता है कि मुझे यही करना होगा - लेकिन आईएमओ - एक वैकल्पिक राज्य को मजबूर करना अवांछनीय है, और मेरे मामले में गठबंधन रेड्यूसर बेकार हो जाता है क्योंकि यह मेरे सख्ती से टाइप किए गए एप्लिकेशन को तोड़ देता है।

मुझे समझ में नहीं आता है कि क्यों assertReducerShape आवश्यक है। यह पहले से ही यहां रनटाइम पर undefined जांच करता है:

https://github.com/reduxjs/redux/blob/231f0b32641059caab3f98a3e04d3afaad19a7d1/src/combineReducers.js#L169

assertReducerShape एक तरह से बेमानी लगता है। लेकिन मेरे मामले में, प्रकार की गारंटी को तोड़ता है ... वह कौन सी चीज है जिस पर जोर देने की कोशिश की जा रही है?

तो, यह वास्तव में एक टाइपस्क्रिप्ट इंटरैक्शन मुद्दा है, तो?

ईमानदार होने के लिए, ऐसा लगता है जैसे यह अंततः दृष्टिकोणों में अंतर है।

combineReducers() जेएस में लिखा गया था, और रनटाइम जांच करने की कोशिश कर रहा है।

आप TS में स्थिर जाँच करने का प्रयास कर रहे हैं, और आपके द्वारा लिखी गई घोषणा combineReducers() वास्तव में कैसे काम करती है, इससे मेल नहीं खाती। तो, उस अर्थ में, अपने टुकड़ा कम करने के लिए प्रकार घोषणा गलत है, क्योंकि यह _can_ और साथ कहा जा _will_ undefined जब साथ प्रयोग किया combineReducers() ।

आपके द्वारा कॉल की गई विशिष्ट लाइन यह जांच कर रही है कि आपके स्लाइस रेड्यूसर का रिटर्न वैल्यू undefined जब एक (संभवतः सार्थक) मौजूदा स्टेट स्लाइस वैल्यू के साथ कॉल किया जाता है, जबकि assertReducerShape() यह जांच रहा है कि यह undefined वापस नहीं करता है जब undefined का प्रारंभिक राज्य मूल्य दिया जाता है (यानी, रेड्यूसर अपने राज्य को स्वयं प्रारंभ करता है) और जब भी अज्ञात क्रिया प्रकार के साथ बुलाया जाता है (यानी, रेड्यूसर हमेशा मौजूदा स्थिति को डिफ़ॉल्ट रूप से लौटाता है)।

यदि आप अपरिभाषित हो रहे हैं, तो इसे बदलें ... मेरे मामले में, जब मेरा सर्वर किसी भी कारण से डेटा के बिना उत्तर देता है, हो सकता है क्योंकि सक्रिय सत्र नहीं है, मुझे वह समस्या मिली है, इसलिए इसे रेड्यूसर में करने के रूप में काम किया मेरे लिए एक आकर्षण:

export default function itemReducer(state = initialState.items | undefined, action){ 
    switch(action.type) 
   { 
         case "LOAD_ITEMS_SUCCESS":
               if(action.items==undefined) { 
                        action.items=[]; 
               }
                return action.items

यदि रेड्यूसर अपरिभाषित हो जाता है, तो अपरिभाषित को एक खाली सरणी के लिए बदलें, और आपको वह त्रुटि अब नहीं मिलेगी।

चीयर्स!