从Redux-Saga函数更新另一个Redux Store的最优方案

针对你这个把Redux状态拆分为ads和tasks两个模块，需要从Saga里更新另一个模块Store的场景，我整理了几个最合理的实现方式，按推荐优先级排序：

1. 触发目标模块的Action（最符合Redux原则） #

这是最标准的做法——遵循Redux的单向数据流，在当前模块的Saga中，通过put方法触发目标模块的Action，由目标模块自己的Reducer来处理状态更新。

举个例子：假设创建任务成功后，需要把关联的广告标记为“已分配任务”，你可以在tasks的Saga里dispatch一个ads模块的Action：

// tasks/sagas.js
import { put, call } from 'redux-saga/effects';
import { createTaskSuccess } from './tasksSlice';
// 导入ads模块的action
import { markAdsAsAssigned } from '../ads/adsSlice';

function* createTaskSaga(action) {
  try {
    // 调用API创建任务
    const newTask = yield call(api.createTask, action.payload);
    // 先更新tasks模块的状态
    yield put(createTaskSuccess(newTask));
    
    // 触发ads模块的Action，传递需要更新的广告ID和任务ID
    yield put(markAdsAsAssigned({
      adIds: newTask.linkedAdIds,
      taskId: newTask.id
    }));
  } catch (err) {
    // 错误处理逻辑
  }
}

然后在ads模块的Reducer里处理这个Action：

// ads/adsSlice.js
import { createSlice } from '@reduxjs/toolkit';

const adsSlice = createSlice({
  name: 'ads',
  initialState: { items: [] },
  reducers: {
    markAdsAsAssigned: (state, action) => {
      const { adIds, taskId } = action.payload;
      // 更新对应广告的状态
      state.items = state.items.map(ad => 
        adIds.includes(ad.id) ? { ...ad, assignedTaskId: taskId } : ad
      );
    }
  }
});

export const { markAdsAsAssigned } = adsSlice.actions;
export default adsSlice.reducer;

这个方式的核心优势是模块解耦：tasks模块只需要触发Action，不需要关心ads模块如何更新状态；ads模块的状态始终由自己的Reducer管理，职责清晰，易于维护。

2. 用Redux Toolkit的extraReducers监听其他模块的Action（推荐给RTK用户） #

如果你用的是Redux Toolkit（现在官方推荐的Redux开发方式），可以在目标模块的Slice中，通过extraReducers直接监听其他模块的Action，自动更新状态。

比如，让ads模块自己监听tasks模块的createTaskSuccess Action，当任务创建成功时自动更新关联广告：

// ads/adsSlice.js
import { createSlice } from '@reduxjs/toolkit';
// 导入tasks模块的action
import { createTaskSuccess } from '../tasks/tasksSlice';

const adsSlice = createSlice({
  name: 'ads',
  initialState: { items: [] },
  reducers: {
    // ads模块自身的Action处理
  },
  extraReducers: (builder) => {
    // 监听tasks模块的createTaskSuccess Action
    builder.addCase(createTaskSuccess, (state, action) => {
      const newTask = action.payload;
      // 更新关联广告的状态
      state.items.forEach(ad => {
        if (newTask.linkedAdIds.includes(ad.id)) {
          ad.assignedTaskId = newTask.id;
        }
      });
    });
  }
});

export default adsSlice.reducer;

这种方式比第一种更简洁：tasks模块不需要额外触发ads的Action，只需要正常处理自己的业务逻辑；ads模块主动监听相关事件，自己维护状态，耦合度更低，是RTK下的最佳实践之一。

3. 直接调用目标模块的Reducer（不推荐，特殊场景可用） #

这个方式可以直接在Saga中获取当前状态，调用目标模块的Reducer计算新状态，再dispatch Action更新。但它会打破Redux的单向数据流，让模块之间产生强耦合，所以除非是非常特殊的场景，不建议使用。

示例代码：

// tasks/sagas.js
import { put, select, call } from 'redux-saga/effects';
import { createTaskSuccess } from './tasksSlice';
import adsReducer from '../ads/adsSlice';
import { setAdsState } from '../ads/adsSlice';

function* createTaskSaga(action) {
  try {
    const newTask = yield call(api.createTask, action.payload);
    yield put(createTaskSuccess(newTask));
    
    // 获取当前ads的状态
    const currentAdsState = yield select(state => state.ads);
    // 调用ads的Reducer计算新状态
    const newAdsState = adsReducer(currentAdsState, {
      type: 'ads/markAdsAsAssigned',
      payload: { adIds: newTask.linkedAdIds, taskId: newTask.id }
    });
    //  dispatch Action更新ads状态
    yield put(setAdsState(newAdsState));
  } catch (err) {
    // 错误处理
  }
}

这个方式的问题在于：tasks模块需要知道ads模块的Reducer逻辑，一旦ads的Reducer修改，tasks的Saga可能也要跟着改，维护成本很高。

总结一下：优先选择方案1或方案2，它们都遵循Redux的设计理念，模块解耦，易于维护；方案3尽量避免使用。

内容的提问来源于stack exchange，提问作者CHY