Могу ли я отправлять несколько действий без промежуточного ПО Redux Thunk?

Я читал, что Redux Thunk - надежный способ управлять асинхронными действиями/запросами. Ничего особенного в том, чтобы отправлять действия другими действиями.

Как насчет отправки синхронных действий? Я не уверен в проблемах производительности подхода, но могу ли я просто отправить действие внутри другого создателя действия без определения функции внутри?

Мне кажется, что использование этой проблемы не требуется для этой потребности.

Ответы

Ответ 1

Отображение и скрытие уведомлений делает действительно хорошим вариантом использования для thunks.

ответ Дэвидса описывает "стандартный" способ сделать несколько обновлений в ответ на что-то: обрабатывать его из разных редукторов. Чаще всего это то, что вы хотите сделать.

Иногда (как и с уведомлениями) может быть неудобно. Я описываю, как вы можете выбирать между отправкой одного или нескольких действий в мой ответ на этот вопрос.

Если вы решите отправить несколько действий, просто сделайте это последовательно от своих компонентов или используйте Redux Thunk. Обратите внимание: если Redux Thunk вам кажется загадочным, перед тем, как использовать его, вы должны понять, что это на самом деле. Это дает только преимущества с точки зрения организации кода; в действительности его не отличается от запуска dispatch() два раза подряд.

Тем не менее, с Redux Thunk отправка нескольких действий выглядит следующим образом:

function increment() {
  return { type: 'INCREMENT' }
}

function incrementTwice() {
  return dispatch => {
    dispatch(increment())
    dispatch(increment())
  }
}

store.dispatch(increment())
incrementTwice()(store.dispatch) // doesn’t require redux-thunk but looks ugly
store.dispatch(incrementTwice()) // requires redux-thunk but looks nice

Использование Redux Thunk не будет иметь проблем с производительностью. Его просто хороший способ вызова функций, с которыми вы можете передать свой dispatch, чтобы они могли делать это столько раз, сколько они хотят.

Ответ 2

Ошибочно думать о действиях для изменения состояния как индивидуального. Они на самом деле многие ко многим. Помните, что все действия вызывают на всех редукторах.

Например, одно действие может вызвать несколько изменений состояния:

function firstReducer(state, action) {
    switch (action.type) {
        case ACTION_X:
            // handle action x
    }
}

function secondReducer(state, action) {
    switch (action.type) {
        case ACTION_X:
            // handle action x
    }
}

function thirdReducer(state, action) {
    switch (action.type) {
        case ACTION_X:
            // handle action x
    }
}

И наоборот, одно и то же изменение состояния может быть результатом двух разных действий.

function firstReducer(state, action) {
    switch (action.type) {
        case ACTION_X:
        case ACTION_Y:
            // handle action x and y in the same manner
    }
}

Может показаться странным обрабатывать два действия таким же образом, но это только в контексте одного редуктора. Другие редукторы могут свободно обрабатывать их по-разному.

function secondReducer(state, action) {
    switch (action.type) {
        case ACTION_X:
            // handle action x
        case ACTION_Y:
            // handle action y
    }
}

function thirdReducer(state, action) {
    switch (action.type) {
        case ACTION_X:
            // handle action x
        default:
            // ignore action y
    }
}

С этим отношением "многие ко многим" просто нет необходимости иметь иерархию действий. Если у вас есть создатели действий, которые запускают несколько синхронных действий, ваш код становится более сложным и сложнее рассуждать.

Ответ 3

Если это, то да, используя:

store.dispatch(action1, action2)

Может быть +1 в github?