javascript - 使用带有ES6发生器的redux-saga与带有ES2017异步/等待的redux-thunk的优点/缺点

现在有很多人在谈论Redux镇的最新孩子,redux-saga/redux-saga。它使用生成器功能来监听/调度操作。
在我开始思考之前,我想知道使用redux-saga的优点/缺点,而不是下面的方法,我使用的是带async/await的redux-thunk
组件可能看起来像这样,像往常一样调度操作。

import { login } from 'redux/auth';

class LoginForm extends Component {

  onClick(e) {
    e.preventDefault();
    const { user, pass } = this.refs;
    this.props.dispatch(login(user.value, pass.value));
  }

  render() {
    return (<div>
        <input type="text" ref="user" />
        <input type="password" ref="pass" />
        <button onClick={::this.onClick}>Sign In</button>
    </div>);
  } 
}

export default connect((state) => ({}))(LoginForm);

然后我的动作看起来像这样:
// auth.js

import request from 'axios';
import { loadUserData } from './user';

// define constants
// define initial state
// export default reducer

export const login = (user, pass) => async (dispatch) => {
    try {
        dispatch({ type: LOGIN_REQUEST });
        let { data } = await request.post('/login', { user, pass });
        await dispatch(loadUserData(data.uid));
        dispatch({ type: LOGIN_SUCCESS, data });
    } catch(error) {
        dispatch({ type: LOGIN_ERROR, error });
    }
}

// more actions...

// user.js

import request from 'axios';

// define constants
// define initial state
// export default reducer

export const loadUserData = (uid) => async (dispatch) => {
    try {
        dispatch({ type: USERDATA_REQUEST });
        let { data } = await request.get(`/users/${uid}`);
        dispatch({ type: USERDATA_SUCCESS, data });
    } catch(error) {
        dispatch({ type: USERDATA_ERROR, error });
    }
}

// more actions...


最佳答案:

在Redux Saga中,上述示例的等效值为

export function* loginSaga() {
  while(true) {
    const { user, pass } = yield take(LOGIN_REQUEST)
    try {
      let { data } = yield call(request.post, '/login', { user, pass });
      yield fork(loadUserData, data.uid);
      yield put({ type: LOGIN_SUCCESS, data });
    } catch(error) {
      yield put({ type: LOGIN_ERROR, error });
    }  
  }
}

export function* loadUserData(uid) {
  try {
    yield put({ type: USERDATA_REQUEST });
    let { data } = yield call(request.get, `/users/${uid}`);
    yield put({ type: USERDATA_SUCCESS, data });
  } catch(error) {
    yield put({ type: USERDATA_ERROR, error });
  }
}

首先要注意的是,我们使用yield call(func, ...args)形式调用API函数。call不执行效果,它只创建一个简单的对象,如{type: 'CALL', func, args}。执行委托给Redux SAGA中间件,该中间件负责执行函数并恢复生成器及其结果。
主要优点是可以使用简单的相等性检查在Redux之外测试生成器
const iterator = loginSaga()

assert.deepEqual(iterator.next().value, take(LOGIN_REQUEST))

// resume the generator with some dummy action
const mockAction = {user: '...', pass: '...'}
assert.deepEqual(
  iterator.next(mockAction).value, 
  call(request.post, '/login', mockAction)
)

// simulate an error result
const mockError = 'invalid user/password'
assert.deepEqual(
  iterator.throw(mockError).value, 
  put({ type: LOGIN_ERROR, error: mockError })
)

注意,我们只是通过将模拟数据注入迭代器的next方法来模拟API调用结果。模拟数据比模拟函数简单得多。
要注意的第二件事是调用yield take(ACTION)。thunk由操作创建者在每个新操作上调用(例如LOGIN_REQUEST)。也就是说,动作不断地被推到thunk,thunk无法控制何时停止处理这些动作。
在Redux Saga中,发电机拉动下一个动作。也就是说,他们可以控制什么时候听一些动作,什么时候不听。在上面的示例中,流指令被放置在一个while(true)循环中,因此它将监听每个传入操作,这有点类似于thunk pushing行为。
pull方法允许实现复杂的控制流。例如,假设我们想要添加以下要求
处理注销用户操作
第一次成功登录后,服务器将返回一个令牌,该令牌将在存储在expires_in字段中的某个延迟内过期。我们必须在每个expires_in毫秒的时间在后台刷新授权
考虑到当等待API调用的结果(初始登录或刷新)时,用户可以在两者之间注销。
您将如何通过thunks实现这一点;同时还为整个流程提供完整的测试覆盖范围?以下是它与传奇的关系:
function* authorize(credentials) {
  const token = yield call(api.authorize, credentials)
  yield put( login.success(token) )
  return token
}

function* authAndRefreshTokenOnExpiry(name, password) {
  let token = yield call(authorize, {name, password})
  while(true) {
    yield call(delay, token.expires_in)
    token = yield call(authorize, {token})
  }
}

function* watchAuth() {
  while(true) {
    try {
      const {name, password} = yield take(LOGIN_REQUEST)

      yield race([
        take(LOGOUT),
        call(authAndRefreshTokenOnExpiry, name, password)
      ])

      // user logged out, next while iteration will wait for the
      // next LOGIN_REQUEST action

    } catch(error) {
      yield put( login.error(error) )
    }
  }
}

在上面的示例中,我们使用race表示并发性需求。如果take(LOGOUT)赢得比赛(即用户单击注销按钮)。比赛将自动取消authAndRefreshTokenOnExpiry后台任务。如果authAndRefreshTokenOnExpiry在一个call(authorize, {token})呼叫中被阻塞,它也会被取消。取消自动向下传播。
您可以找到一个runnable demo of the above flow