Dva: प्रभाव कैसे रद्द करें

आप मॉडल की सदस्यता में रूटिंग परिवर्तनों की निगरानी कर सकते हैं, और मैन्युअल रूप से मॉडल A की स्थिति को तब साफ़ कर सकते हैं जब पृष्ठ एक गैर-A पृष्ठ हो (एक पृष्ठ छोड़ें) या एक पृष्ठ (एक पृष्ठ दर्ज करें)।

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

मुझे मूल पोस्टर की समस्या का सामना करना पड़ा है। घटक की स्थापना रद्द होने पर मैं अधूरा प्रभाव रद्द करना चाहता था, लेकिन मैंने पाया कि कोई रास्ता नहीं था। डीवीए इस तरह की एपीआई @sorrycc प्रदान नहीं करता है

क्या प्रभावों को रद्द करना और सागों को अलग करना संभव है

@dlamon को उसी स्थिति का सामना करना पड़ा और मार्ग बंद होने पर सफाई करना चाहता था। क्या अब कोई समाधान है?

रूट स्विच के दौरान @KyrieChen के साफ होने की उम्मीद नहीं है, क्योंकि रूट स्विच पूरा होने के बाद, संचार वापस नहीं आ सकता है, और संचार वापस आने के बाद भी गंदे डेटा को साफ किए गए मॉडल डेटा क्षेत्र में वापस लिखा जाएगा।

मेरा वर्तमान दृष्टिकोण मॉडल डेटा क्षेत्र में यूयूआईडी के साथ एक उप-डेटा क्षेत्र उत्पन्न करना है जो वर्तमान लेनदेन के अनुरूप हर बार जब मैं एक लेनदेन दर्ज करता हूं (जब कॉम्पोनेंटविलमाउंट), जिसका उपयोग वर्तमान लेनदेन में उपयोग किए गए डेटा को संग्रहीत करने के लिए किया जाता है। यूयूआईडी लिखा है और लेन-देन से बाहर निकलने पर साफ़ हो जाता है (componentWillUnmount)। नीचे मॉडल संरचना के समान:

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

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

@dlamon मैं भी इसमें भाग गया। मैंने खुद एक डेमो लिखा था, और मुझे थोड़ी समस्या हो रही है https://codesandbox.io/s/yqwqpmvwvj

रद्द करें namespace से products से model में effect विधि:
dispatch({ type: 'products/@<strong i="10">@CANCEL_EFFECTS</strong>' });

क्या यह कोड है?

        yield sagaEffects.fork(function*() {
          yield sagaEffects.take(`${model.namespace}/@@CANCEL_EFFECTS`);
          yield sagaEffects.cancel(task);
        });

@ wss1942 इस विधि का उत्तर देने के लिए धन्यवाद। मैंने इसे आजमाया। यदि प्रेषण ({type:'products/@ @CANCEL_EFFECTS '}) संबंधित मोडल में प्रभाव को अमान्य कर देगा। #796 . से मिलता-जुलता

@dlamon dva एक प्रभाव को साफ़ करने के लिए एक एपीआई प्रदान नहीं करता है। हालाँकि, मॉडल में परिभाषित प्रभाव में कई गाथाएँ लिखी जा सकती हैं।

 namespace: 'products',
 effects: {
  *start(){},
  *stop(){},
  watchLogin: [
      function* ({ take, put, call, cancel, fork, cancelled }) {
          yield take('start');
          const timerTask = yield fork(timer)
          const bgSyncTask = yield fork(bgSync)
          yield take('stop')
          yield cancel(bgSyncTask)
          yield cancel(timerTask)

        function* bgSync() {
          try {
            while (true) {
              const result = yield call(delay, 5 * 1000);
              yield put({ type: 'stop' })
            }
          } finally {
            if (yield cancelled())
              yield put({ type: 'log', payload: 'fetch🛑' })
          }
        }
        function* timer(time) {
          let i=0;
          while (true) {
            yield put({ type: 'log', payload: i++ })
            yield delay(1000)
          }
        }
      },
      { type: 'watcher' },
    ],
}

bgSync आपका एसिंक्रोनस कार्य है, आप कार्य को क्रिया के साथ प्रारंभ कर सकते हैं : कार्य को क्रिया के साथ प्रारंभ और रद्द करें: रोकें । यह एक निश्चित प्रभाव को रद्द करने के लिए प्राप्त किया जा सकता है।
इसके अलावा, यदि अतुल्यकालिक कार्य एक नेटवर्क अनुरोध है, तो उसे नेटवर्क अनुरोध को रद्द करने के लिए एक ऑपरेशन की भी आवश्यकता हो सकती है। उदाहरण के लिए, axios को axios.CancelToken के साथ रद्द किया जा सकता है।

@ wss1942 धन्यवाद!
इस तरह, प्रभावों को रद्द किया जा सकता है। लोडिंग स्थिति प्रदर्शित करना अधिक परेशानी वाला है। आप सीधे लोडिंग का उपयोग नहीं कर सकते हैं। लोडिंग स्थिति प्रदर्शित करने के लिए डीवीए के साथ आने वाले प्रभाव। इसे बदलने के लिए आपको अपना कोड लिखना होगा।
मैंने इसे संशोधित किया और एक पूर्ण मॉडल कोड पोस्ट किया

import { getProduct } from '@/services/Products';
import { isRespSucc, showErrorMsg } from '@/utils/utils';

const initState = {};

export default {
  namespace: 'product',

  state: initState,

  effects: {
    /**
      在两个 Effects 之间触发一个竞赛（race）
      如果task先结束，竞赛结束。
      如果task未结束时收到cancel，race effect 将自动取消 task。
    */
    *cancelable({ task, payload }, { call, race, take }) {
      yield race({
        task: call(task, payload),
        cancel: take('cancel'),
      });
    },

    /**
      取消所有未完成的任务，并执行数据清理
    */
    *clear(_, { put }) {
      yield put.resolve({ type: 'cancel' });
      yield put({ type: 'clearState' });
    },

    *getProduct({ payload }, { call, put, cancelled }) {
      // eslint-disable-next-line
      yield put.resolve({ type: 'cancelable', task: getProductCancelable, payload });

      function* getProductCancelable(params) {
        try {
          // 调用网络请求
          const response = yield call(getProduct, params);
          // 返回结果判断
          if (!isRespSucc(response)) {
            showErrorMsg(response);
            return;
          }
          // 取值
          const { productName } = response.data;
          // 调用reducer存值
          yield put({
            type: 'saveState',
            payload: { productName },
          });
        } finally {
          if (yield cancelled()) {
            // TODO: 取消网络请求
          }
        }
      }
    },
    *getCity(_, { call, put, cancelled }) {
      // eslint-disable-next-line
      yield put.resolve({ type: 'cancelable', task: getCityCancelable });

      function* getCityCancelable() {
        // TODO: 具体实现
      }
  },

  reducers: {
    saveState(state, { payload }) {
      const newState = { ...state, ...payload };
      return newState;
    },
    clearState() {
      return initState;
    },
  },
};

लेन-देन छोड़ते समय (componentWillUnmount), डिस्पैच क्लियर वर्तमान मॉडल में सभी अधूरे प्रभावों को रद्द कर सकता है, और getProductLoading और getCityLoading का भी सामान्य रूप से उपयोग किया जा सकता है।

  componentWillMount() {
    const { dispatch } = this.props;
    dispatch({
      type: 'product/getProduct',
      payload: {
        productNumber: '123456',
      },
    });
    dispatch({
      type: 'product/getCity',
    });
  }

  componentWillUnmount() {
    const { dispatch } = this.props;
    dispatch({
      type: 'product/clear',
    });
  }

  function mapStateToProps(state) {
    return {
      getProductLoading: state.loading.effects['product/getProduct'],
      getCityLoading: state.loading.effects['product/getCity'],
    };
  }