女人吃精子的好处与功效,无码人妻一区二区三区,国产伦子系列沙发午睡

簡述

redux-saga是用于維護redux異步操作的狀態的一個中間件實現，其中reducer負責處理state更新，sagas負責協調異步操作。它提供了一系列的side-effects方法，可以讓用戶很優雅的實現一些異步功能。本文從源碼出發，結合一個簡單實現，探索工具的實現原理。

整體

前言

redux-saga中廣泛采用了Generator進行編程實現side-effect，如果對Generator不熟悉，可以參考下Generator 函數的語法。
由于是redux的異步擴展，redux-saga中廣泛應用了redux中的很多函數，比如applyMiddleware、dispatch、getState等。如對redux不熟悉，建議看下redux源碼；本文也會提供一個無redux依賴的簡單實現。
redux-saga的源碼地址: redux-saga/redux-saga，后續會以examples文件下counter為例子配合源碼閱讀。
redux-saga提供了很多effect方法，如：take（只監聽一次action）、takeEvery（一直監聽某一action）、put（觸發一個action）、call（阻塞調用一個函數，如一個Promise方法）等，本文只解析counter例子中用到的方法，了解了核心代碼運行機制后，其他方法的理解就簡單多了。

例子

counter的功能很簡單，其中Increment async這一選項和redux-saga直接相關。看下和異步相關的代碼：

sags/index.js:

// 異步執行邏輯
export function* incrementAsync() {
  yield call(delay, 1000) // 延遲1000ms
  yield put({type: 'INCREMENT'}) // 執行INCREMENT的reducer
}
// redux-saga入口，每次觸發INCREMENT_ASYNC事件就會執行incrementAsync邏輯
export default function* rootSaga() {
  yield takeEvery('INCREMENT_ASYNC', incrementAsync)
}

reducers/index.js

// reducer邏輯，沒什么好說的
export default function counter(state = 0, action) {
  switch (action.type) {
    case 'INCREMENT':
      return state + 1
    case 'INCREMENT_IF_ODD':
      return (state % 2 !== 0) ? state + 1 : state
    case 'DECREMENT':
      return state - 1
    default:
      return state
  }
}

main.js

// 創建saga中間件，sagaMonitor是輔助的監控功能
const sagaMiddleware = createSagaMiddleware({sagaMonitor})
// 把saga中間加入redux中
const store = createStore(
  reducer,
  applyMiddleware(sagaMiddleware)
)
// 執行saga中間件，而且只執行一次，
sagaMiddleware.run(rootSaga)

// redux邏輯，包括綁定action、渲染
const action = type => store.dispatch({type})
function render() {
  ReactDOM.render(
    <Counter
      value={store.getState()}
      onIncrement={() => action('INCREMENT')}
      onDecrement={() => action('DECREMENT')}
      onIncrementIfOdd={() => action('INCREMENT_IF_ODD')}
      onIncrementAsync={() => action('INCREMENT_ASYNC')} />,
    document.getElementById('root')
  )
}
render()
store.subscribe(render)

redux-saga

入口

上面的例子中main.js，通過createSagaMiddleware和sagaMiddleware.run(rootSaga)引入redux-saga邏輯，在middleware.js中createSagaMiddleware綁定sagaMiddleware的run函數，并返回sagaMiddleware，調用sagaMiddleware.run其實就是調用了runsaga.js中的主邏輯：

// sagaMiddleware
export default function sagaMiddlewareFactory({ context = {}, ...options } = {}) {
  ...
  // sagaMiddleware.run其實調用的是runsage
  function sagaMiddleware({ getState, dispatch }) {
    const sagaEmitter = emitter()
    sagaEmitter.emit = (options.emitter || ident)(sagaEmitter.emit)
    // 為runSaga提供redux的函數以及subscribe
    sagaMiddleware.run = runSaga.bind(null, {
      context,
      subscribe: sagaEmitter.subscribe,
      dispatch,
      getState,
      sagaMonitor,
      logger,
      onError,
    })
    // 按照redux插件要求，返回一個函數
    return next => action => {
      const result = next(action) //  reducers
      sagaEmitter.emit(action)
      return result
    }
  }
  ...
}

// runsaga.js
export function runSaga(storeInterface, saga, ...args) {
  ...
  iterator = saga(...args)  // 執行入口邏輯，例子sags/index.js中的rootsaga
  // storeInterface主要提供redux的函數
  const { subscribe, dispatch, getState, context, sagaMonitor, logger, onError } = storeInterface
  // 執行
  const task = proc(
    iterator,
    subscribe,
    wrapSagaDispatch(dispatch),
    getState,
    context,
    { sagaMonitor, logger, onError },
    effectId,
    saga.name,
  )
  ...
}

內部執行

下圖是邏輯執行的概略圖，以takeEvery為例。圖中每一種顏色的線表示一次執行循環。

內部執行邏輯.png

redux-saga的內部邏輯執行主要包括以下幾點：

proc：proc是運行的核心，effect方法適配其運行機制。
事件channel：每次proc執行都會生成一個事件channel，如果當前上下文執行邏輯后有take類型，那么會往channel中塞入對應的回調函數，否則channel為空。redux的action會通過sagaEmitter.emit(action)觸發事件channel中的回調，如果channel中事件匹配的回調，執行對應邏輯。
fork：可以對比linux中fork進行理解。每次fork都會執行proc函數生成一個新的task。
take: 塞入當前作用域下的事件channel一個回調函數，此回調函數的主邏輯是proc中的next函數。
put：遍歷事件channel，執行匹配的回調

proc主要干了兩件事情：

生成事件訂閱通道，用于存放回調函數
執行一次Generator對象iterator的next，根據結果執行對應類型的effect

export default function proc(
  iterator,
  subscribe = () => noop,
  dispatch = noop,
  getState = noop,
  parentContext = {},
  options = {},
  parentEffectId = 0,
  name = 'anonymous',
  cont,
) {
  // subscribe為redux的訂閱函數
  // 后續redux的dispatch操作都會調用channel中的訂閱函數
  const stdChannel = _stdChannel(subscribe)
  ...
  next()
  return task
  function next(arg, isErr) {
    ...
    // 執行Generator
    result = iterator.next(arg)
    if (!result.done) {
      runEffect(result.value, parentEffectId, '', next) // next
    }
    ...
  }

runEffect根據類型執行邏輯：如果是take類型，封裝回調加入當前作用域下的事件channel，初始化操作完成；如果是fork，進入proc邏輯：

// cb是proc中的next函數，維持proc中的作用域
function runEffect(effect, parentEffectId, label = '', cb) {
  // 封裝回調
  function currCb(res, isErr) {
    ...
    cb(res, isErr)
  }
  ...
  let data
  // 根據effect的類型，執行對應的邏輯，take、fork、call、cps等等
  return (
    ...
    : (data = asEffect.take(effect))          ? runTakeEffect(data, currCb)
    : (data = asEffect.fork(effect))          ? runForkEffect(data, effectId, currCb)
    ...
  )
}

// cb的主要邏輯是proc的next函數
// 執行take后，邏輯到一段落
function runTakeEffect({ channel, pattern, maybe }, cb) {
  channel = channel || stdChannel
  const takeCb = inp => (inp instanceof Error ? cb(inp, true) : isEnd(inp) && !maybe ? cb(CHANNEL_END) : cb(inp))
  // 回調加入事件channel
  channel.take(takeCb, matcher(pattern))
  ...
}

// cb的主要邏輯是proc中的next
function runForkEffect({ context, fn, args, detached }, effectId, cb) {
  // 創建iterator，如果fn是iterator，直接返回fn，否者執行fn，如果fn()的返回result是iterator，返回result；如都不滿足，那么自我創建
  const taskIterator = createTaskIterator({ context, fn, args })
  // 執行proc，一次嵌套
  const task = proc(taskIterator, subscribe, dispatch, getState, taskContext, options, effectId, fn.name,
      detached ? null : noop)
  ...
  // 執行上一次proc的next方法
  cb(task)
  ...
}

需要特別注意下sagaHelpers的實現，例如takeEveryHelper，它返回一個類iterator的對象，便于后續的遍歷和執行。

當有redux事件進來時，會觸發channel中的事件回調。回調函數是基于proc中next函數的封裝，執行過程會觸發一次fork和take，takeEvery借助的takeEveryHelper核心邏輯：

function takeEveryHelper(patternOrChannel, worker, ...args) {
  const yTake = { done: false, value: take(patternOrChannel) }
  const yFork = ac => ({ done: false, value: fork(worker, ...args, ac) }) 
  let action, setAction = ac => (action = ac)
  // 創建iterator函數，實現自定義next邏輯：q1() -> q2() -> q1() 循環進行下去
  // 執行第一步，會進入runTake邏輯
  // 執行第二步，會進入runFork，在runFork中會再執行一次runTake
  // 因此函數會按照：  q1()  -->   q2()->q1()  -->  q2()->q1()  --> ...  這種循環執行下去
  return fsmIterator(
    {
      q1() {
        return ['q2', yTake, setAction]
      },
      q2() {  // 觸發事件時，進行此步操作，返回一個fork對象
        return action === END ? [qEnd] : ['q1', yFork(action)]
      },
    },
    'q1',
    `takeEvery(${safeName(patternOrChannel)}, ${worker.name})`,
  )
}

function fsmIterator(fsm, q0, name = 'iterator') {
  let updateState,
    qNext = q0

  function next(arg, error) {
    ...
    let [q, output, _updateState] = fsm[qNext]()
    qNext = q
    return qNext === qEnd ? done : output
  }
  // 封裝返回iterator類型對象
  return makeIterator(next, error => next(null, error), name, true)
}

demo

下面是參考redux-saga做的一個簡單的實現，它不依賴redux，也只實現了takeEvery這一個saga：

// 常量和校驗函數
const MATCH = 'shouldNotMATCHTAg';
const isFunc = f => typeof f === 'function';
const isIterator = fn => fn && isFunc(fn.next);

// 事件channel，take塞入回調，put觸發回調函數
function channel() {
  const subscribers = [];
  function take(sub, matcher) {
    sub[MATCH] = matcher
    subscribers.push(sub)
  }
  function put(item) {
    const arr = subscribers.slice();
    for (var i = 0, len = arr.length; i < len; i++) {
      const cb = arr[i];
      if (!cb[MATCH] || cb[MATCH](item)) {
        arr.splice(i, 1);
        return cb(item);
      }
    }
  }
  return {
    take,
    put,
  }
}
const chan = new channel();


// 核心主邏輯
function proc(iterator, args) {
  next();
  // 遍歷執行Generator對象
  function next() {
    let result = iterator.next();
    if (!result.done) {  // 依據返回類型執行effect
      runEffect(result.value, next);
    } else {
      console.log('done');
    }
  }
  function runEffect(obj, cb) {
    if (obj.type == 'fork') {
      runForkEffect(obj, cb);
    } else if (obj.type == 'take') {
      runTakeEffect(obj, cb);
    }
  }
  // fork類型，執行一次proc
  function runForkEffect({context, fn, args}, cb) {
    // 創建iterator對象
    function createTaskIterator({context, fn, args}) {
      if (isIterator(fn)) {
        return fn;
      }
      let result = fn.apply(context, args);
      if (isIterator(result)) {
        return result;
      }
    }
    let result = createTaskIterator({context, fn, args})
    proc(result);
    cb();
  }
  // take類型，往事件channel中塞入回調
  function runTakeEffect({pattern}, cb) {
    chan.take(cb, (input) => input == pattern);
  }
}

// takeEvery的邏輯，每種不同類型，如 call、put進行內部處理邏輯以適配核心
function takeEvery(type, fn) {
  // 每種邏輯，比如takeEvery,call,put都不同
  function takeEveryHelper(pattern, worker) {
    function fsmIterator(fsm, q0) {
      const done = { done: true, value: undefined }
      const qEnd = {};
      let qNext = q0;
      function next(arg, error) {
        let [q, output] = fsm[qNext]()
        qNext = q
        return qNext === qEnd ? done : output;
      }
      return {next};
    }
    // 注意fsmIterator的邏輯，銜接兩次遍歷
    return fsmIterator({
      q1() {
        return ['q2', { done: false, value: { type: 'take', pattern } }]
      },
      q2() {
        return ['q1', { done: false, value: { type: 'fork', fn: worker } }]
      }
    }, 'q1');
  }
  // takeEvery是fork類型
  return {
    type: 'fork',
    context: null,
    args: [type, fn],
    fn: takeEveryHelper
  }
}
// 入口
function* root() {
  yield takeEvery('INCREMENT_ASYNC1', incrementAsync)
}
// 增加
function *incrementAsync() {
  value = value +1;
  document.getElementById('count').innerHTML = value;
}


proc(root());

附上可執行代碼地址：redux-saga。

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

redux-saga源碼解讀

redux-saga源碼解讀

簡述

整體

前言

例子

redux-saga

入口

內部執行

demo

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

redux-saga源碼解讀

簡述

整體

前言

例子

redux-saga

入口

內部執行

demo

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频