var token = 'spo';

switch(token){
    case ( (token.match(/spo/) )? token : undefined ) :
       console.log('MATCHED')    
    break;;
    default:
       console.log('NO MATCH')
    break;;
}

——>如果匹配成功，三元表达式返回原始令牌 ---->原始令牌按大小写计算

——>如果没有匹配，三元返回undefined ----> Case对未定义的令牌进行计算，希望您的令牌不是。

三元测试可以是任何东西，例如在你的例子中

( !!~ base_url_string.indexOf('xxx.dev.yyy.com') )? xxx.dev.yyy.com : undefined 

===========================================

(token.match(/spo/) )? token : undefined ) 

三元表达式。

本例中的测试是token.match(/spo/)，它声明token中包含的字符串与正则表达式/spo/(在本例中是字面字符串spo)的匹配。

如果表达式和字符串匹配，则返回true并返回token(这是switch语句正在操作的字符串)。

显然，token === token可以匹配switch语句并计算case

如果你在层中看它，并理解翻转测试是在switch语句之前求值的，因此switch语句只看到测试的结果，这就更容易理解了。

RegExp也可以用match方法用于输入字符串。

为了确保在case子句中有匹配，我们将根据成功匹配的输入属性测试原始str值(提供给switch语句的值)。

Input是正则表达式的静态属性，包含原始输入字符串。

当匹配失败时，它返回null。为了避免异常错误，我们在访问输入属性之前使用可选的链接操作符(或传统ES中的逻辑||条件操作符)。

const str = 'XYZ test';

switch (str) {
  case str.match(/^xyz/)?.input:
    console.log("Matched a string that starts with 'xyz'");
    break;
  case str.match(/test/)?.input:
    console.log("Matched the 'test' substring");        
    break;
  default:
    console.log("Didn't match");
    break;
}

另一种方法是使用String()构造函数将结果数组转换为字符串，该数组必须只有一个元素(没有捕获组)，并且必须使用量词(.*)捕获整个字符串。在失败的情况下，null对象将成为一个'null'字符串。这似乎不太方便。

const str = 'XYZ test';

switch (str.toLowerCase()) {
  case String(str.match(/^xyz.*/i)):
    console.log("Matched a string without case sensitivity");
    break;
  case String(str.match(/.*tes.*/)):
    console.log("Matched a string using a substring 'tes'");
    break;
}

不管怎样，一个更优雅的解决方案是使用test方法而不是match，即/^find-this-in/.test(str)与switch (true)，它只是返回一个布尔值，并且更容易匹配，不区分大小写。

const str = 'haystack';

switch (true) {
  case /^hay.*/i.test(str):
    console.log("Matched a string that starts with 'hay'");
    break;
}

然而，在这种情况下使用if else else if语句也是可读的

另一种选择是使用regexp匹配结果的输入字段:

str = 'XYZ test';
switch (str) {
  case (str.match(/^xyz/) || {}).input:
    console.log("Matched a string that starts with 'xyz'");
    break;
  case (str.match(/test/) || {}).input:
    console.log("Matched the 'test' substring");        
    break;
  default:
    console.log("Didn't match");
    break;
}

这可能更容易。试着这样想:

首先捕获常规字符之间的字符串 然后找到"case"

:

// 'www.dev.yyy.com'
// 'xxx.foo.pl'

var url = "xxx.foo.pl";

switch (url.match(/\..*.\./)[0]){
   case ".dev.yyy." :
          console.log("xxx.dev.yyy.com");break;

   case ".some.":
          console.log("xxx.foo.pl");break;
} //end switch

如果需要使用正则表达式，请为开关情况创建一个带有正则表达式和条件响应的对象

let test = (str) => {
    let obj = {
        'foo':'bar',
        '\/albums?':'photo'
    };
    for(let prop in obj){
        if(new RegExp(prop).test(str))return obj[prop]
    };
};

switch(test(location.href)){
    case 'bar':
        console.log('url has bar')
    break;
}

你也可以像这样使用默认的情况:

    switch (name) {
        case 't':
            return filter.getType();
        case 'c':
            return (filter.getCategory());
        default:
            if (name.startsWith('f-')) {
                return filter.getFeatures({type: name})
            }
    }