redux saga - rootsaga - ¿Cuál es la diferencia entre el tenedor y el engendro en la saga redux?

redux saga tutorial español

Question

Los docs dicen que el tenedor es un tenedor adjunto y el engendro es un tenedor separado , ¿en qué se diferencian?

Answer 1

En los mismos documentos dice:

Cuando el padre termina la ejecución de su propio cuerpo de instrucciones, esperará a que todas las tareas bifurcadas terminen antes de regresar.

Digamos que tenemos esta configuración en la que, en medio del flujo de ejecución, llamamos fetchAll() que podría llamar a fork o spawn :

const { delay, runSaga } = require("redux-saga");
const fetch = require("node-fetch");
const { fork, spawn, call, put} = require("redux-saga/effects");


function* fetchResource(resource) {
    console.log(`Fetch ${resource} start`);
    const response = yield call(fetch, "https://jsonplaceholder.typicode.com" + resource);
    const text = yield call(response.text.bind(response));
    console.log(`Fetch ${resource} end`);
}

function* fetchAll() {
    console.log("Fork or Spawn start");
    // this is pseudo code, I mean here that you can use either
    // fork or spawn, check results below
    const task1 = yield fork||spawn(fetchResource, "/posts/1"); 
    const task2 = yield fork||spawn(fetchResource, "/posts/2");
    console.log("Fork or Spawn end");
}

function* main() {
    console.log("Main start");
    yield call(fetchAll);
    console.log("Main end");
}

runSaga({}, main);

// RESULTS WITH FORK():   |  RESULTS WITH SPAWN():
//                        |
// Main start             |  Main start
// Fork start             |  Spawn start
// Fetch /posts/1 start   |  Fetch /posts/1 start
// Fetch /posts/2 start   |  Fetch /posts/2 start
// Fork end               |  Spawn end
// Fetch /posts/2 end     |  Main end <-- 
// Fetch /posts/1 end     |  Fetch /posts/2 end
// Main end <--           |  Fetch /posts/1 end

Lo que vemos es que, dentro del contexto de la call la bifurcación non-blocking está non-blocking , pero la call no se terminará hasta que todos los procesos secundarios estén finalizados, ya que la call sí misma es un efecto de bloqueo.

No vería lo mismo si llama a una fork dentro de otra fork , ya que la bifurcación en sí misma no es de bloqueo, y los procesos de la bifurcación interna se leak fuera de los procesos de la horquilla externa, pero se mantendrán dentro del contexto de bloqueo más cercano. Esta es la esencia del attachment to parent .

Por lo tanto, la yield call(forkedProcess) padres yield call(forkedProcess) de naturaleza de bloqueo esperará la throw resolution de return o throw resolution de los procesos de las bifurcaciones secundarias.

Sin embargo, este no es el caso con el spawn() , ya que el spawn se separa del proceso padre adjunto, es decir, se adjunta al proceso raíz, por lo que el parent local no tiene que esperar.

Espero que esto lo aclare un poco.

Answer 2

Una forma de verlo es ver tu saga como un gráfico. ''fork'' crea un hijo a partir del proceso de llamada. Mientras que ''spawn'' crea un nuevo hijo en la raíz del gráfico.

Por lo tanto, cuando "bifurca" otro proceso, el proceso principal esperará hasta que finalice el proceso "bifurcado". Además, todas las excepciones pasarán del niño al padre y se pueden capturar en el padre.

Sin embargo, un proceso ''generado'' no bloqueará al padre, por lo que la siguiente declaración de ''rendimiento'' se llama inmediatamente. Además, el proceso principal no podrá detectar ninguna excepción que ocurra en el proceso ''generado''.

Espero que esto haya sido útil.