Redux-Saga работает дважды для одного действия

Question

У меня есть сага для обработки как запросы. Пользователь нажимает кнопку, чтобы переключить понравившийся статус фотографии.

Сага прислушивается к действию типа SUBMIT_LIKE. Моя проблема в том, что submitLikeSaga работает дважды за каждое действие SUBMIT_LIKE. , например. В случае api-error одно действие SUBMIT_LIKE вызывает два вызова api и четыре действия RECEIVE_LIKE.

(с использованием react-boilerplate, если это помогает.)

export function* submitLikeSaga(action) { 

    // optimistically update the UI 
    // action shape: { 
    // type: RECEIVE_LIKE, 
    // like: {id: 1, liked: true} 
    // } 
    yield put(receiveLike(action.like)); 

    // POST like data to api 
    const response = yield call(
    request, 
    `${API_ENDPOINT}/user_likes.json`, 
    { 
     method: 'POST', 
     headers: { 
     Authorization: `Bearer ${action.token}`, 
     Accept: 'application/json', 
     'Content-Type': 'application/json', 
     }, 
     body: JSON.stringify(action.like), 
    } 
); 

    // if api call failed, reverse change made to UI 
    if (response.err) { 
    yield put(receiveLike({ 
     id: action.like.id, 
     liked: !action.like.liked, 
    })); 
    } 
} 

export function* watchSubmitLike() { 
    yield* takeEvery(SUBMIT_LIKE, submitLikeSaga); 
} 

// All sagas to be loaded 
export default [ 
    watchFetchUsers, 
    watchSubmitLike, 
]; 

EDIT: Добавить промежуточное программное обеспечение и просматривать код.

ProfileGrid.js

const ProfileGrid = ({ 
    users, 
    submitLike, 
    token, 
}) => 
    <div className={styles.profileGrid}> 
    {users.map((user, i) => (
     <div key={i} className={styles.gridTile}> 
     <GridTile 
      title={user.username} 
      actionIcon={<ActionIcon 
      onIconClick={() => { submitLike(user.id, !user.liked, token); }} 

      isActive={user.liked} 
      activeColor="yellow" 
      defaultColor="white" 
      />} 
     > 
      <img style={{ width: '100%', height: 'auto' }} src={user.avatar} alt="profile" /> 
     </GridTile> 
     </div> 
    ))} 
    </div>; 

ActionIcon.js

const ActionIcon = ({ 

    onIconClick, 
    isActive, 
    activeColor, 
    defaultColor, 
}) => 
    <IconButton onClick={onIconClick} > 
    <StarBorder 
     color={isActive ? activeColor : defaultColor} 
    /> 
    </IconButton>; 

store.js

/** 
* Create the store with asynchronously loaded reducers 
*/ 

import { createStore, applyMiddleware, compose } from 'redux'; 
import { fromJS } from 'immutable'; 
import { routerMiddleware } from 'react-router-redux'; 
import createSagaMiddleware from 'redux-saga'; 
import createReducer from './reducers'; 

const sagaMiddleware = createSagaMiddleware(); 
const devtools = window.devToolsExtension || (() => (noop) => noop); 

export default function configureStore(initialState = {}, history) { 
    // Create the store with two middlewares 
    // 1. sagaMiddleware: Makes redux-sagas work 
    // 2. routerMiddleware: Syncs the location/URL path to the state 
    const middlewares = [ 
    sagaMiddleware, 
    routerMiddleware(history), 
    ]; 

    const enhancers = [ 
    applyMiddleware(...middlewares), 
    devtools(), 
    ]; 

    const store = createStore(
    createReducer(), 
    fromJS(initialState), 
    compose(...enhancers) 
); 

    // Extensions 
    store.runSaga = sagaMiddleware.run; 
    store.asyncReducers = {}; // Async reducer registry 

    // Make reducers hot reloadable, see http://mxs.is/googmo 
    /* istanbul ignore next */ 
    if (module.hot) { 
    module.hot.accept('./reducers',() => { 
     System.import('./reducers').then((reducerModule) => { 
     const createReducers = reducerModule.default; 
     const nextReducers = createReducers(store.asyncReducers); 

     store.replaceReducer(nextReducers); 
     }); 
    }); 
    } 

    return store; 
} 

asyncInjectors.js

import { conformsTo, isEmpty, isFunction, isObject, isString } from 'lodash'; 
import invariant from 'invariant'; 
import warning from 'warning'; 
import createReducer from '../reducers'; 

/** 
* Validate the shape of redux store 
*/ 
export function checkStore(store) { 
    const shape = { 
    dispatch: isFunction, 
    subscribe: isFunction, 
    getState: isFunction, 
    replaceReducer: isFunction, 
    runSaga: isFunction, 
    asyncReducers: isObject, 
    }; 
    invariant(
    conformsTo(store, shape), 
    '(app/utils...) asyncInjectors: Expected a valid redux store' 
); 
} 

/** 
* Inject an asynchronously loaded reducer 
*/ 
export function injectAsyncReducer(store, isValid) { 
    return function injectReducer(name, asyncReducer) { 
    if (!isValid) checkStore(store); 

    invariant(
     isString(name) && !isEmpty(name) && isFunction(asyncReducer), 
     '(app/utils...) injectAsyncReducer: Expected `asyncReducer` to be a reducer function' 
    ); 

    store.asyncReducers[name] = asyncReducer; // eslint-disable-line no-param-reassign 
    store.replaceReducer(createReducer(store.asyncReducers)); 
    }; 
} 

/** 
* Inject an asynchronously loaded saga 
*/ 
export function injectAsyncSagas(store, isValid) { 
    return function injectSagas(sagas) { 
    if (!isValid) checkStore(store); 

    invariant(
     Array.isArray(sagas), 
     '(app/utils...) injectAsyncSagas: Expected `sagas` to be an array of generator functions' 
    ); 

    warning(
     !isEmpty(sagas), 
     '(app/utils...) injectAsyncSagas: Received an empty `sagas` array' 
    ); 

    sagas.map(store.runSaga); 
    }; 
} 

/** 
* Helper for creating injectors 
*/ 
export function getAsyncInjectors(store) { 
    checkStore(store); 

    return { 
    injectReducer: injectAsyncReducer(store, true), 
    injectSagas: injectAsyncSagas(store, true), 
    }; 
} 

Answer 1

Привет, ваше приложение будет работать нормально, если вы сделаете следующее:

выход * takeEvery (SUBMIT_LIKE, submitLikeSaga); должен быть

выход takeEvery (SUBMIT_LIKE, submitLikeSaga);

Вы должны использовать выход * только тогда, когда вы секвенирования сагах

Answer 2

Согласно документации: https://redux-saga.js.org/docs/api/index.html#takelatestpattern-saga-args это будет ваш последний звонок и и будет срабатывать только одно действие

import { fork, takeLatest } from 'redux-saga/effects'; 

export function* watchSubmitLike() { 
    yield fork(takeLatest, SUBMIT_LIKE, submitLikeSaga); 

}