Javascript 使用React、Redux和Immutable.js创建模式弹出窗口

在我的项目中，我希望能够为登录和注册帐户等事项发送模式弹出窗口。我的问题是，我希望它们能够用于任何目的，但我不确定如何以“反应方式”来实现。起初，我想这样做：

/常量/Modal.js

export const DISPATCH = 'MODAL/DISPATCH';
export const UPDATE = 'MODAL/UPDATE';
export const DISMISS = 'MODAL/DISMISS';

import {
    DISPATCH,
    UPDATE,
    DISMISS
} from '../constants/Modal';

export function dispatch(type, props) {
    return {
        type: DISPATCH,
        payload: {type, props}
    };
}

export function update(props) {
    return {
        type: UPDATE,
        payload: {props}
    };
}

export function dismiss() {
    return {type: DISMISS};
}

import {Map} from 'immutable';

import {
    DISPATCH,
    UPDATE,
    DISMISS
} from '../constants/Modal';

const initialState = Map({
    type: '',
    props: Map(),
    isDispatched: false
});

export default function modalReducer(state = initialState, action) {
    switch (action.type) {
        case DISPATCH:
            return state.set('type', action.payload.type)
                .set('props', Map(action.payload.props))
                .set('isDispatched', true);
        case UPDATE:
            return state.set('props', Map(action.payload.props));
        case DISMISS:
            return state.set('isDispatched', false);
        default:
            return state;
    }
}

/actions/Modal.js

export const DISPATCH = 'MODAL/DISPATCH';
export const UPDATE = 'MODAL/UPDATE';
export const DISMISS = 'MODAL/DISMISS';

import {
    DISPATCH,
    UPDATE,
    DISMISS
} from '../constants/Modal';

export function dispatch(type, props) {
    return {
        type: DISPATCH,
        payload: {type, props}
    };
}

export function update(props) {
    return {
        type: UPDATE,
        payload: {props}
    };
}

export function dismiss() {
    return {type: DISMISS};
}

import {Map} from 'immutable';

import {
    DISPATCH,
    UPDATE,
    DISMISS
} from '../constants/Modal';

const initialState = Map({
    type: '',
    props: Map(),
    isDispatched: false
});

export default function modalReducer(state = initialState, action) {
    switch (action.type) {
        case DISPATCH:
            return state.set('type', action.payload.type)
                .set('props', Map(action.payload.props))
                .set('isDispatched', true);
        case UPDATE:
            return state.set('props', Map(action.payload.props));
        case DISMISS:
            return state.set('isDispatched', false);
        default:
            return state;
    }
}

/减速器/Modal.js

export const DISPATCH = 'MODAL/DISPATCH';
export const UPDATE = 'MODAL/UPDATE';
export const DISMISS = 'MODAL/DISMISS';

import {
    DISPATCH,
    UPDATE,
    DISMISS
} from '../constants/Modal';

export function dispatch(type, props) {
    return {
        type: DISPATCH,
        payload: {type, props}
    };
}

export function update(props) {
    return {
        type: UPDATE,
        payload: {props}
    };
}

export function dismiss() {
    return {type: DISMISS};
}

import {Map} from 'immutable';

import {
    DISPATCH,
    UPDATE,
    DISMISS
} from '../constants/Modal';

const initialState = Map({
    type: '',
    props: Map(),
    isDispatched: false
});

export default function modalReducer(state = initialState, action) {
    switch (action.type) {
        case DISPATCH:
            return state.set('type', action.payload.type)
                .set('props', Map(action.payload.props))
                .set('isDispatched', true);
        case UPDATE:
            return state.set('props', Map(action.payload.props));
        case DISMISS:
            return state.set('isDispatched', false);
        default:
            return state;
    }
}

---

组件将启动这些操作，然后ModalContainer组件将根据

state.modal.get（'type'）

呈现相应的弹出窗口，并将

state.modal.get（'props'）

传递给模态组件。这样做的问题是，道具最终会包括组件的子级和各种方法，而这些都与存储无关。如何从不是ModalContainer组件子组件的组件中呈现弹出窗口，而不执行类似于

React.render（，document.getElementById（'modal-container'））

？

我描述了一种类似的模式对话方式。
根据我的经验，我只是不传递带有有效负载的非序列化道具

例如，我不会传递子对象，而是将行为封装在适当的模态组件本身中，例如

。然后由

DeleteUserModal

根据需要连接到存储，检索所需数据，分派操作，并选择要渲染的子级

或者，您可以完全避免通过Redux路由模态，只需使用这样的方式即可：

做一些愚蠢的事情，比如

React.render（，document.getElementById（'modal-container'）？

---

（这不是愚蠢的，人们称这种模式为“门户”。

我描述了一种类似的模式对话方式。
根据我的经验，我只是不传递带有有效负载的非序列化道具

例如，我不会传递子对象，而是将行为封装在适当的模态组件本身中，例如

。然后由

DeleteUserModal

根据需要连接到存储，检索所需数据，分派操作，并选择要渲染的子级

或者，您可以完全避免通过Redux路由模态，只需使用这样的方式即可：

做一些愚蠢的事情，比如

React.render（，document.getElementById（'modal-container'）？

（这不是愚蠢的，人们称这种模式为“门户”。）