Qu'est-ce que le idiomatiques de façon de commencer rootSaga?

Question

redux-projet saga a été existant depuis un temps assez long maintenant, mais il ya encore beaucoup de choses confuses à propos de cette bibliothèque. Et l'un d'eux est: comment faire pour démarrer votre rootSaga. Par exemple, dans le tutoriel pour débutant rootSaga est commencé par yeilding un tableau de sagas. Comme ceci

export default function* rootSaga() {
  yield [
    helloSaga(),
    watchIncrementAsync()
  ]
}

Cependant, à l' aide de la saga aides section rootSaga se compose de deux fourches sagas. Comme ceci:

export default function* rootSaga() {
  yield fork(watchFetchUsers)
  yield fork(watchCreateUser)
}

De la même façon de départ rootSaga est utilisé dans async exemple dans redux-saga des pensions. Toutefois, si vous vérifiez dans le monde réel et le shopping de la carte d'exemples, vous verrez que rootSagas il y a le rendement d'un tableau de fourche sagas. Comme ceci:

export default function* root() {
  yield [
    fork(getAllProducts),
    fork(watchGetProducts),
    fork(watchCheckout)
  ]
}

Aussi, si vous avez lu quelques discussions dans redux-saga des questions, vous verrez que certaines personnes suggèrent d'utiliser spawn à la place de la fourche pour rootSaga de garde vous demande de compléter plantage si l'un de vos fourches sagas est annulée en raison de certains exception non gérée.

Donc, ce qui est le plus à droite façon de commencer votre rootSaga? Et quelles sont les différences entre les existants?

Answer 1

Vous pouvez commencer à racine multiple sagas. Mais toute saga a la possibilité de démarrer une autre saga sur son propre. Ainsi, il est possible de commencer une unique racine de la saga, qui crée les autres sagas.

Vous avez juste besoin d'être conscient de la façon dont les erreurs se propagent à la mère de la saga. Si vous avez une unique racine de la saga et un enfant de la saga s'est écrasé, par défaut, l'erreur se propage à la société mère qui se terminent, ce qui permettra également de tuer tous les autres sagas commencé à partir de ce parent.

C'est à vous de décider de ce comportement. Selon votre demande, vous voudrez peut-être avoir un échec rapide du comportement (faire de l'ensemble de l'application inutilisable si il y a un problème), ou " fail-safe, et d'essayer de faire l'application de continuer à travailler, même si certaines parties peuvent avoir des problèmes.

En général, je vous recommande de commencer racine multiple sagas, ou un de vos parents saga utilise spawn au lieu de fork , de sorte que votre application reste utilisable si il y a une chute. Notez qu'il est également très facile d'oublier de repérer les erreurs dans certains endroits. En général, vous ne voulez pas, par exemple, d'avoir tous vos app inutilisable si il y a une API unique de demande qui ne

Edit: je vous recommande de jeter un oeil à https://github.com/yelouafi/redux-saga/issues/570

Dans ce redux-saga question, je montre les différentes façons de démarrer les sagas et l'impact qu'il a sur votre application.

TLDR: c'est la façon dont j'ai l'habitude de commencer à la racine de sagas:

const makeRestartable = (saga) => {
  return function* () {
    yield spawn(function* () {
      while (true) {
        try {
          yield call(saga);
          console.error("unexpected root saga termination. The root sagas are supposed to be sagas that live during the whole app lifetime!",saga);
        } catch (e) {
          console.error("Saga error, the saga will be restarted",e);
        }
        yield delay(1000); // Workaround to avoid infinite error loops
      }
    })
  };
};

const rootSagas = [
  domain1saga,
  domain2saga,
  domain3saga,
].map(makeRestartable);

export default function* root() {
  yield rootSagas.map(saga => call(saga));
}

Answer 2

Comment créer rootSaga?

Selon un développeur principal de redux-saga [1,2] la idiomatiques façon de créer rootSaga est d'utiliser tous les Effets du Combinator. Aussi, veuillez noter que le rendement de tableaux à partir de sagas est obsolète.

Exemple 1

Vous pouvez utiliser quelque chose comme ceci (+tous)

import { fork, all } from 'redux-saga/effects';
import firstSaga from './firstSaga';
import secondSaga from './secondSaga';
import thirdSaga from './thirdSaga';

export default function* rootSaga() {
    yield all([
        fork(firstSaga),
        fork(secondSaga),
        fork(thirdSaga),
    ]);
}

Exemple 2

Prises à partir d'ici

// foo.js
import { takeEvery } from 'redux-saga/effects';
export const fooSagas = [
  takeEvery("FOO_A", fooASaga),
  takeEvery("FOO_B", fooBSaga),
]

// bar.js
import { takeEvery } from 'redux-saga/effects';
export const barSagas = [
  takeEvery("BAR_A", barASaga),
  takeEvery("BAR_B", barBSaga),
];

// index.js
import { fooSagas } from './foo';
import { barSagas } from './bar';

export default function* rootSaga() {
  yield all([
    ...fooSagas,
    ...barSagas
  ])
}

fourche vs spawn

fourche et frayer permettra à la fois de retour Tâche des objets. Fourche tâches sont attachés à la mère, tandis que les donné naissance à des tâches sont détachés de la mère.

• La gestion des erreurs dans les fourches [lien]:

  Les erreurs de l'enfant tâches automatiquement bulle jusqu'à leurs parents. Si tout en fourche tâche génère une erreur non interceptée, puis le parent tâche avorter avec l'enfant d'Erreur, et l' ensemble du Parent de l'exécution de l'arbre (c'est à dire en fourche tâches + la tâche principale représentée par le parent du corps si il est toujours en cours) sera annulé.

• Gestion des erreurs dans les donné naissance à des tâches [lien]:

  Le parent ne sera pas attendre pour la maison d'tâches à la fin avant de la retourner et de tous les événements qui peuvent affecter le parent ou le détachement de la tâche sont complètement indépendants (erreur, annulation).

Basé sur la ci-dessus, vous pouvez, utiliser une fourchette pour "mission critique" des tâches, c'est à dire "si cette tâche échoue, veuillez crash de l'ensemble de l'application", et se reproduisent pour "non critique", les tâches, c'est à dire "si cette tâche échoue, ne pas propager l'erreur de la mère".