Dois-je conserver les références de fonction dans Redux magasin?

TL;DR: Vous n'avez pas. Le magasin de l'etat doivent être sérialisables à tous les temps (que Nathan a répondu).
Le Redux est via les exhausteurs de, ou le Redux Observables par dépendances.

Basé sur le Redux docs exemple, ce que vous voulez, c'est de passer la référence de votre action(1), de l'ignorer votre réducteur(2) et à utiliser dans votre enhancer(3):

//... in your action:
const data={val:1},ref=()=>{};
const action = {type:'ACTION_WITH_REF', data:data:, ref: ref}; //(1)

//... in your reducer:
case 'ACTION_WITH_REF':
return {...state, data: action.data}

//... and in your enhancer:
import { createStore, applyMiddleware } from 'redux'
import reducers from './reducers'
export const myRefStore= {};
 
function refHandler({ getState }) {
  return next => action => {
    switch(action.type){ //this can be done more elegantly with redux-observable
     case 'ACTION_WITH_REF':
     myRefStore.aRef = action.ref //(3)
     break;
 }
    const returnValue = next(action)   
    return returnValue
  }
} 
const store = createStore(
  reducers,
  initialState,
  applyMiddleware(refHandler)
)

Remarque: aussi loin Qu'il n'y a pas d'effets secondaires dans vos amplificateurs, vous êtes bon pour aller. Soyez conscient que vous pourriez avoir obtenu les refs directement dans les réducteurs, mais une telle approche maintient la référence à l'réducteur de niveau et rate le point de combineReducers(). Avec un amplificateur, vous les gardez tous en un seul endroit(myRefStore). Une dernière observation est qu'un redux magasin n'est pas un tout-magasin de données, mais un magasin d'état, donc pourquoi nous devons nous occuper des fonctions et d'autres non-état des choses dans des amplificateurs. Vous pouvez tirer parti de la mise en réseau de base pour les Redux Observables et injecter myRefStore via dépendances.

J'ai eu de très bons résultats en ajoutant des fonctions de mon redux magasin. Si vos fonctions agissent comme des méthodes à appliquer la logique aux données, il peut être incroyablement puissant tout au long de votre application (plus JSON.stringify enlèvent les fonctions, de toute façon, de sorte que vous pouvez toujours sérialiser votre magasin et de l'enregistrer pour le stockage local ou que ce soit.) Ci-dessous j'ai un currentUser réducteur qui utilise une classe de l'état initial, et comprend un hasPermissions méthode qui peut être appelé n'importe où le currentUser est connecté. C'est particulièrement agréable car chaque fois que j'carte currentUser de mes accessoires, je n'ai pas besoin de rappeler à l'importation de certains types de util qui va analyser l'utilisateur de voir si il a les autorisations pour afficher quelque chose. La méthode est déjà sur l'utilisateur.

  class CurrentUser {
    constructor() {
      this.permissions = []
      this.roles = []
      this.admin = false
    }

    hasPermission = (permission) => {
      if (this.admin) { return true }
      if (Array.isArray(permission)) {
        return permission.reduce((prev, curr) => {
          if (!prev) { return false }
          if (this.permissions.indexOf(curr) > -1) { return true }
          return false
        }, true)
      }
      return this.permissions.indexOf(permission) > -1
    }
  }

  const initialState = new CurrentUser()

  const curretUserReducer = (state = initialState, action) => {
    const { type, payload } = action
    switch (type) {
      case ACTIONS.SET_CURRENT_USER: {
        const { user } = payload
        return Object.assign(new CurrentUser(), user)
      }
      case ACTIONS.CLEAR_CURRENT_USER: {
        return new CurrentUser()
      }
      case ACTIONS.UPDATE_CURRENT_USER: {
        const newCurrentUser = merge(state, payload.user)
        storage.set('currentUser', JSON.stringify(newCurrentUser))
        return newCurrentUser
      }
      default:
        return state
    }
  }

  export default curretUserReducer