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

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;
}

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语句也是可读的

使用位置即可。主机属性

switch (location.host) {
    case "xxx.local":
        settings = ...
        break;
    case "xxx.dev.yyy.com":
        settings = ...
        break;
}

可能太迟了，但我喜欢这个，以防万一。

function extractParameters(args) {
    function getCase(arg, key) {
        return arg.match(new RegExp(`${key}=(.*)`)) || {};
    }

    args.forEach((arg) => {
        console.log("arg: " + arg);
        let match;
        switch (arg) {
            case (match = getCase(arg, "--user")).input:
            case (match = getCase(arg, "-u")).input:
                userName = match[1];
                break;

            case (match = getCase(arg, "--password")).input:
            case (match = getCase(arg, "-p")).input:
                password = match[1];
                break;

            case (match = getCase(arg, "--branch")).input:
            case (match = getCase(arg, "-b")).input:
                branch = match[1];
                break;
        }
    });
};

你可以更进一步，传递一个选项列表，用|处理正则表达式

独立版本，增加工作安全性:

switch((s.match(r)||[null])[0])

function identifyCountry(hostname,only_gov=false){ const exceptionRe = /^(?:uk|ac|eu)$/ ; //https://en.wikipedia.org/wiki/Country_code_top-level_domain#ASCII_ccTLDs_not_in_ISO_3166-1 const h = hostname.split('.'); const len = h.length; const tld = h[len-1]; const sld = len >= 2 ? h[len-2] : null; if( tld.length == 2 ) { if( only_gov && sld != 'gov' ) return null; switch( ( tld.match(exceptionRe) || [null] )[0] ) { case 'uk': //Britain owns+uses this one return 'gb'; case 'ac': //Ascension Island is part of the British Overseas territory //"Saint Helena, Ascension and Tristan da Cunha" return 'sh'; case null: //2-letter TLD *not* in the exception list; //it's a valid ccTLD corresponding to its country return tld; default: //2-letter TLD *in* the exception list (e.g.: .eu); //it's not a valid ccTLD and we don't know the country return null; } } else if( tld == 'gov' ) { //AMERICAAA return 'us'; } else { return null; } } <p>Click the following domains:</p> <ul onclick="console.log(`${identifyCountry(event.target.textContent)} <= ${event.target.textContent}`);"> <li>example.com</li> <li>example.co.uk</li> <li>example.eu</li> <li>example.ca</li> <li>example.ac</li> <li>example.gov</li> </ul>

说实话，你可以做一些

function switchableMatch(s,r){
    //returns the FIRST match of r on s; otherwise, null
    const m = s.match(r);
    if(m) return m[0];
    else return null;
}

然后切换(switchableMatch(s,r)){…}

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语句只看到测试的结果，这就更容易理解了。