Redux处理异步的中间件redux-saga

有关于异步处理，通用解决方案有这些： redux-thunk，redux-promise，redux-saga
最后为什么选择了redux-saga，因为thunk 和 promise 都有的问题是：他们改变了 action 的含义，使得 action 变得不那么纯粹了。

redux-saga 是一个用于管理应用程序 Side Effect（副作用，例如异步获取数据，访问浏览器缓存等）的 library，它的目标是让副作用管理更容易，执行更高效，测试更简单，在处理故障时更容易。

Effect 被称为副作用，在我们的应用中，最常见的就是异步操作。它来自于函数编程的概念，之所以叫副作用是因为它使得我们的函数变得不纯，同样的输入不一定获得同样的输出。

redux-saga 是一个 redux 中间件，意味着这个线程可以通过正常的 redux action 从主应用程序启动，暂停和取消，它能访问完整的 redux state，也可以 dispatch redux action。

启动运行 Sagas：

import { createStore, , applyMiddleware } from 'redux'
import createSagaMiddleware from 'redux-saga'
import reducer from './reducers'

//要运行的 Sagas
import sagas from './sagas'

//创建一个 Saga middleware
const sagaMiddleware = createSagaMiddleware()

const store = createStore(
  reducer,
// 将 middleware 连接至 Store
  applyMiddleware(sagaMiddleware)
)
//运行 Sagas
sagaMiddleware.run(sagas)
//执行 
store.dispatch(action)

applyMiddleware(...middleware)是一种推荐用来扩展 Redux的方式，告诉 createStore() 如何处理中间件，让你包装 store 的 dispatch方法来达到你想要的目的。

创建一个 Saga:

saga被实现为Generator函数 (我梳理的Generator 函数)，让异步的流程更易于读取，写入和测试。通过这样的方式，这些异步的流程看起来就像是标准同步的 Javascript 代码。

//只是单纯的创建了saga，打印了一条消息，没有进行异步调用
function* helloSaga() {
  console.log('Hello Sagas!');
}

Sagas的基本使用：

• Effect 是一个简单的对象，这个对象包含了一些给 middleware 解释执行的信息，可以把 Effect 看作是发送给 middleware 的指令以执行某些操作（调用某些异步函数，发起一个 action 到 store，等等）。

• Effect 创建器：创建一个 Effect 描述信息，只返回一个普通 Javascript 对象，并不会执行任何操作。执行是由 middleware进行的，middleware会检查每个 Effect 的描述信息，并进行相应的操作。

• Saga 辅助函数：是构建在 Effect 创建器之上的辅助函数。（即高级 API）

执行dispatch：put(action)

创建一个 Effect 描述信息，用来命令 middleware 向 Store 发起一个 action( 这个 effect 是非阻塞型的 )。

import { put } from 'redux-saga/effects'

function* example() {
  yield put({ type: 'CHESTNUT' })
}

阻塞与非阻塞形式调用：call(fn, ...args)，fork(fn, ...args)

• fork和call共同点：
  都是创建一个 Effect 描述信息，用来命令 middleware以参数 args 调用函数 fn（fn可以是一个普通函数，也可以是一个Generator函数）

• fork和call区别点：
  call： 是一个会阻塞的 Effect，即 Generator 在调用结束之前不能执行或处理任何其他事情。
  fork：非阻塞调用 的形式执行 fn（Generator 不会在等待 fn 返回结果的时候被 middleware 暂停，它在 fn 被调用时便会立即恢复执行）

import { take, put, fork ,call } from 'redux-saga/effects'
//一个工具函数 delay，用于阻塞执行 ms 毫秒，并返回 val 值。
//delay(ms, [val])
import { delay } from 'redux-saga'

function* example1() {
  yield call({delay , 1000})
  //过1秒后打印出'print call'
  console.log('print call')
}

function* chestnut() {
    yield fork({delay , 1000})
  //直接打印出'print fork'
    console.log('print fork')
}

监听action：take(pattern)

创建另一个命令对象，告诉 middleware 等待一个指定的 action。
在 take 的情况中，与 action 被推向任务处理函数不同，Saga 是自己主动拉取 action 的。

import { put, take } from 'redux-saga/effects'

//用户执行3次 CHESTNUT 后才会执行 CHESTNUT_ONE，然后Generator 会被回收并且相应的监听不会再发生
function* chestnutOne() {
  for (let i = 0; i < 3; i++) {
    yield take('CHESTNUT_CREATION')
  }
    yield put({type: 'CHESTNUT_SUCCEED'})
}

function* chestnutTwo() {
//用户监听 2 个并发的 action，如果用户执行了CHESTNUT_ONE或CHESTNUT_TWO，则会执行 CHESTNUT_ONE
  while (true) {
    yield take(['CHESTNUT_ONE', 'CHESTNUT_TWO'])
    yield put({type: 'CHESTNUT_NUM'})
  }
}

sagas辅助函数：takeEvery(pattern, saga, ...args) ,takeLatest(pattern, saga, ...args)

sagas辅助函数是使用 take 和 fork 构建的高级 API

• takeEvery()：会存在 多个 saga任务

import {  fork , take } from 'redux-saga/effects'
import { takeEvery } from 'redux-saga'

function* onesaga(action) {
  ...
}

function* chestnutOne() {
  yield takeEvery('CHESTNUT_REQUESTED', onesaga)
}

//takeEvery用低阶 Effects 的实现
const takeEvery = (pattern, saga, ...args) => fork(function*() {
  while (true) {
    const action = yield take(pattern)
    yield fork(saga, ...args.concat(action))
  }
})

• takeLatest()：只会存在 一个 saga任务，会自动取消之前已经启动但仍在执行中的 saga 任务。

import {  fork , take ,cancel } from 'redux-saga/effects'
import { takeLatest } from 'redux-saga'

function* onesaga(action) {
  ...
}
function* chestnutTwo() {
  yield takeLatest('CHESTNUT_REQUESTED', onesaga)
}

//takeLatest 用低阶 Effects 的实现
const takeLatest = (pattern, saga, ...args) => fork(function*() {
  let lastTask
  while (true) {
    const action = yield take(pattern)
    if (lastTask) {
      yield cancel(lastTask) // 如果任务已经结束，则 cancel 为空操作
    }
    lastTask = yield fork(saga, ...args.concat(action))
  }
})

关于同时启动多个任务：

• 同时启动多个任务，等待所有的 effects 都执行完毕，或者当一个 effect 被拒绝 （就像 Promise.all 的行为）

const [one, two] = yield [
  call(fetch, '/one'),
  call(fetch, '/two')
]

• 同时启动多个任务，不等待所有effects都执行完毕。在多个 Effect 间运行 竞赛（Race）（与 Promise.race([...]) 的行为类似），只拿第一个被 resolve（或 reject）的任务。（注意：race 它会自动取消那些失败的 Effects）

import { race } from 'redux-saga/effects'

//在请求返回之前，可触发CANCEL_FETCH action取消该请求
function* chestnut{
  const { response, cancel } = yield race({
    response: call(fetch),
    cancel: take('CANCEL_FETCH')
  })
}

取消任务：cancel(task)

一旦任务被 fork，可以使用 yield cancel(task) 来中止任务执行，取消正在运行的任务。

import { take, fork, cancel } from 'redux-saga/effects'

function* chestnut() {
  while(true) {
    const task = yield fork(fetch)
    yield take('STOP')
    yield cancel(task)
  }
}

最后整合sagas：

import {all} from 'redux-saga/effects'

//一个入口点，立即启动所有的Sagas
export default function* sagas() {
  yield all([
    example(),
    example1()，
  // more sagas
  ])
}

更多具体详细查看API文档

现在redux项目中的一些问题是：

• 概念太多，并且 reducer, saga, action 都是分离的，需要在 reducer, saga, action 之间来回切换，编辑成本高。
• 在真实的项目应用 redux 中，除了 redux store 的创建，中间件的配置，路由的初始化，Provider 的 store 的绑定，saga 的初始化，还要处理 reducer, component, saga 的 HMR（hot module replacement 模块热替换） ，看起来比较复杂。
• ......

有没有更好的简化方案呢？React + Redux最佳实践实现的framework——dva