在Redux-Observable Epic中分发Action及调用operationReset()的正确方式是什么？

Great questions! Let's break this down clearly since these are common pitfalls when working with redux-observable:

1. Correct way to dispatch actions inside an Epic #

The core design of redux-observable is that Epics are pure functions that take an action stream (action$) and return a new action stream. You never need to call store.dispatch() directly—instead, you return an Observable that emits the actions you want to dispatch. The middleware will automatically send these actions to your Redux store.

Here's a simple example:

import { ofType } from 'redux-observable';
import { mergeMap, map, catchError } from 'rxjs/operators';
import { of } from 'rxjs';
import { fetchSuccess, fetchFailure } from './your-actions';

const fetchDataEpic = (action$) => action$.pipe(
  // Listen for the trigger action
  ofType('FETCH_DATA_START'),
  // Handle async logic
  mergeMap((action) => 
    fetch(`/api/data/${action.payload}`).pipe(
      // Dispatch success action when request resolves
      map(response => fetchSuccess(response)),
      // Dispatch failure action if request fails
      catchError(error => of(fetchFailure(error)))
    )
  )
);

Every action emitted by the returned Observable gets dispatched to the store automatically.

2. Correct way to call operationReset() inside an Epic #

Assuming operationReset() is an action creator (a function that returns a Redux action object), you just need to emit it as part of the Observable stream you return from the Epic.

For example, if you want to trigger a reset after a failed request:

import { operationReset } from './your-actions';

const fetchDataEpic = (action$) => action$.pipe(
  ofType('FETCH_DATA_START'),
  mergeMap((action) => 
    fetch(`/api/data/${action.payload}`).pipe(
      map(response => fetchSuccess(response)),
      catchError(error => 
        // Emit both failure and reset actions
        of(
          fetchFailure(error),
          operationReset() // This gets dispatched automatically
        )
      )
    )
  )
);

If operationReset is some other kind of function (not an action creator), you'd still want to wrap it in an action—since Epics should only communicate with the store via actions. Trigger the function by dispatching an action that an Epic (or Redux middleware) listens for to execute the reset logic.

3. Should you import the actual Store to use inside an Epic? #

Absolutely not. Importing the store directly creates tight coupling between your Epic and the store instance, makes testing much harder (you can't easily mock the store), and goes against redux-observable's functional design principles.

The official redux-observable team has explicitly deprecated this approach for good reason. Instead, use the built-in parameters provided to every Epic:

• action$: The stream of incoming actions
• state$: A stream that emits the current Redux state (use withLatestFrom to access it)

Example of accessing state without importing the store:

import { withLatestFrom } from 'rxjs/operators';

const someEpic = (action$, state$) => action$.pipe(
  ofType('SOME_ACTION'),
  // Get the latest state alongside the action
  withLatestFrom(state$),
  map(([action, currentState]) => {
    // Use currentState to decide what action to dispatch next
    return someAction(currentState.someValue);
  })
);

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