Javascript 切换情况，如果情况A或B，我想做一些事情，如果情况A或B，我想做其他事情？

请看这个switch case语句。案例“响应”和“错误”有很多共同点，但也有一条线将它们区分开来

            switch (data.type) {
                case 'response':
                    const transactionId = data.trans_id;
                    const callbacks = commandCallbacks[transactionId];

                    if (!callbacks) {
                        if (logger) logger(`Dropping received message that was not requested, transactionId: ${transactionId}`);
                        break;
                    }

                    clearTimeout(callbacks.timedOutTimer);
                    callbacks.resolver(data);
                    break;
                case 'error':                
                    const transactionId = data.trans_id;
                    const callbacks = commandCallbacks[transactionId];

                    if (!callbacks) {
                        if (logger) logger(`Dropping received message that was not requested, transactionId: ${transactionId}`);
                        break;
                    }

                    clearTimeout(callbacks.timedOutTimer);
                    callbacks.rejecter(data);
                    break;
                case 'information':
                case 'progress':
                default:
                    break;
            }

如何简化此代码

        switch (data.type) {
            case 'error':
            case 'response':
                const transactionId = data.trans_id;
                const callbacks = commandCallbacks[transactionId];

                if (!callbacks) {
                    if (logger) logger(`Dropping received message that was not requested, transactionId: ${transactionId}`);
                    break;
                }

                clearTimeout(callbacks.timedOutTimer);
                 data.type === 'response' ? callbacks.resolver(data) : callbacks.rejecter(data);
                break;
            case 'information':
            case 'progress':
            default:
                break;
        }

---

此外，如果您有更多选项签入开关，您可以将其更改为

if

使用括号表示法和条件运算符访问

回调

上的相应函数属性，然后调用该函数：

switch (data.type) {
  case 'response':
  case 'error':
    const transactionId = data.trans_id;
    const callbacks = commandCallbacks[transactionId];

    if (!callbacks) {
      if (logger) logger(`Dropping received message that was not requested, transactionId: ${transactionId}`);
      break;
    }

    clearTimeout(callbacks.timedOutTimer);
    const fn = callbacks[data.type === 'response' ? 'resolver' : 'rejecter'];
    fn(data);
    break;
    // ...

请注意，如果函数依赖于

此

为

回调

，请改用

.call

：

fn.call(callbacks, data);

---

这实际上与OR和XOR没有任何关系-毕竟不同的

情况都是相互排斥的。
这是我最好的尝试：

            switch (data.type) {
                case 'response':
                case 'error':
                    const transactionId = data.trans_id;
                    const callbacks = commandCallbacks[transactionId];

                    if (!callbacks) {
                        if (logger) logger(`Dropping received message that was not requested, transactionId: ${transactionId}`);
                        break;

                    }
                    clearTimeout(callbacks.timedOutTimer);

                    switch (data.type) {
                        case 'response':
                            callbacks.resolver(data);
                        case 'error':
                            callbacks.rejecter(data);
                    }

                    break;
                case 'information':
                case 'progress':
                default:
                    break;
            }

通过移动您的
案例
语句，让
案例的响应
案例“跌破”到
错误
案例：


开关（数据类型）{
个案‘回应’：
案例“错误”：
const transactionId=data.trans_id；
const callbacks=commandCallbacks[transactionId]；
如果（！回调）{
if（logger）logger（`droping接收到的未请求的消息，transactionId:${transactionId}`）；
打破
}
clearTimeout（callbacks.timedOutTimer）；
如果（data.type==='response'）{
callbacks.resolver（数据）；
}else if（data.type=='error'{
回调。拒绝器（数据）；
}
打破
案件‘资料’：
案件‘进展’：
}
您可以使用一个函数获取回调，然后使用具有正确目标值的对象调用该函数

function getCallbacks({ trans_id }) {
    const callbacks = commandCallbacks[trans_id];
    if (!callbacks) {
        if (logger) logger(`Dropping received message that was not requested, transactionId: ${transactionId}`);
        return;
    }
    return callbacks;
}

switch (data.type) {
    case 'response':
    case 'error':
        let cb = getCallbacks(data);
        if (!cb) break;
        clearTimeout(cb.timedOutTimer);
        cb[{ response: 'resolver', error: 'rejecter' }[data.type]](data);
}

我会完全跳过switch语句，这样写：

if (["reponse", "error"].includes(data.type)) {
    const transactionId = data.trans_id;
    const callbacks = commandCallbacks[transactionId];
    if (callbacks) {
        const callback = {
            response: data => callbacks.resolver(data),
            error: data => callbacks.rejecter(data)
        }[data.type];
        clearTimeout(callbacks.timedOutTimer);
        callback(data);
    } else if (logger) {
        logger(`Dropping received message that was not requested, transactionId: ${transactionId}`);
    }
}

一般来说，我更喜欢使用对象而不是切换。
很棘手，但很棒！：-）它不适用于两个相同的案例检查。第一个控制流程。后一种情况是不起作用的，因为你已经跌破了——直到断开为止，它结束了开关，不允许返回检查。它只适用于前一种情况，但不适用于后一种情况。我想我明白你的意思了，谢谢你澄清：）