0

通常我们会做以下事情来定义一个 set redux action&reducer with redux-actions library

export const {
  open,
  close,
  send
} = createActions({
  OPEN: payload => ({
    payload
  }),
  CLOSE: payload => ({
    payload
  }),
  SEND: payload => ({
    payload,
  })
});


export const combinedReducer = createActions({
  [open]: (state, action) => { /*you do someting*/ },
  [close]: (state, action) => { /*you do someting*/ },
  [send]: (state, action) => { /*you do someting*/ }
});



/*in some where , we are going to handle the a triggered action type respectively in a switch statement.
but we have to use string concatenation to make the switch express strict equal pass , any graceful solution ? */


switch (action.type) {
  case open + "":
    //do someting
    break;
  case close + "":
    //do someting
    break;
  case send + "":
    //do someting
    break;
}

上面生成的变量open、close、send实际上是 函数类型，它们的 toString()被 redux-action lib 覆盖以导出像"OPEN"、"CLOSE"、"send"这样的字符串

但是，如果我们想在 switch 语句中重用这些动作类型，我们必须以这种尴尬的方式连接 ''来传递 switch 表达式。

在处理执行严格相等比较的 switch 语句解析时，是否有任何优雅的方法可以避免这种愚蠢的代码===

提前致谢。

4

2 回答 2

1

我可能误解了你的问题，所以我之前的回答可能不会接近你想要的。

我使用的另一种技术，同时使用了这两种技术createActions()，switch/case看起来像这样：

import { createAction } from 'redux-actions'

// your action creators
export const myAction = createAction('ACTION_TYPE')

// your store slice/reducers
const defaultSliceState = {}
export const slice = (state = defaultSliceState, action) => {
    switch(action.type) {
        case myAction().type:
            return Object.assign({}, state, { someValue: action.payload })
    }
}

更新

如果您需要强制执行严格的平等，并且不那么担心遵循典型/可爱/整洁的模式，您可以使用这个：

// your store slice/reducers
const ACTION_TYPE_1 = 'ACTION_TYPE_1'
const ACTION_TYPE_2 = 'ACTION_TYPE_2'
// add your action creators here: const myAction = createAction(ACTION_TYPE)
// ...

const defaultSliceState = {}
export const slice = (state = defaultSliceState, action) => {
    switch(true) {
        case action.type === ACTION_TYPE_1:
            return Object.assign({}, state, { someValue: action.payload })
        case action.type === ACTION_TYPE_2:
            return Object.assign({}, state, { otherValue: doSomething(action.payload) })
    }
}

...但如果您唯一关心的是严格平等，您甚至不需要这样做。通过一个小实验，我发现switch/case已经使用了严格的相等检查。

function match (arg) {
  switch(arg) {
    case 1: return "matched num"
    case '1': return "matched str"
  }
}

match(1) // -> matched num
match('1') // -> matched str
于 2018-10-01T13:38:19.050 回答
0

一种方式使用handleActionorhandleActions函数，也由 redux-actions 提供。switch与其用 case 编写长语句，不如[action.type]使用这些函数将 action 创建者映射到 reducer。

这类似于我喜欢这样做：

import { createAction, handleActions } from 'redux-actions'

// your action creators
export const myAction = createAction('ACTION_TYPE`)

// your reducer (this example doesn't do anything useful)
const myReducer = (state, action) => Object.assign({}, state, { someValue: action.payload })

const sliceDefaultValue = {}
export const slice = handleActions({
    [myAction]: myReducer
}, sliceDefaultValue)

handleAction函数文档位于此处：https ://redux-actions.js.org/api/handleaction。

于 2018-10-01T13:02:40.067 回答