Оператор переключения для сопоставления строк в JavaScript

Как мне написать swtich для следующих условных выражений?

Если URL содержит «foo», тогда settings.base_url - это «bar».

Следующее - достижение требуемого эффекта, но я чувствую, что это будет более управляемым в коммутаторе:

var doc_location = document.location.href;
var url_strip = new RegExp("http:\/\/.*\/");
var base_url = url_strip.exec(doc_location)
var base_url_string = base_url[0];

//BASE URL CASES

// LOCAL
if (base_url_string.indexOf('xxx.local') > -1) {
    settings = {
        "base_url" : "http://xxx.local/"
    };
}

// DEV
if (base_url_string.indexOf('xxx.dev.yyy.com') > -1) {
    settings = {
        "base_url" : "http://xxx.dev.yyy.com/xxx/"
    };
}

Вы не можете сделать это за switchисключением случаев, когда вы делаете полное сопоставление строк; это делает сопоставление подстроки . (Это не совсем так, как указывает Шон в комментариях. См. Примечание в конце.)

Если вы счастливы, что ваше регулярное выражение в верхней части удаляет все, что вы не хотите сравнивать в своем совпадении, вам не нужно совпадение подстроки, и вы можете сделать:

switch (base_url_string) {
    case "xxx.local":
        // Blah
        break;
    case "xxx.dev.yyy.com":
        // Blah
        break;
}

... но опять же, это работает, только если это полная строка, которую вы соответствуете. Он потерпит неудачу, если base_url_string, скажем, будет «yyy.xxx.local», тогда как ваш текущий код будет соответствовать этому в ветке «xxx.local».

Обновление : Хорошо, так что технически вы можете использовать switchдля подстроки соответствия, но я бы не рекомендовал его в большинстве ситуаций. Вот как ( живой пример ):

function test(str) {
    switch (true) {
      case /xyz/.test(str):
        display("• Matched 'xyz' test");
        break;
      case /test/.test(str):
        display("• Matched 'test' test");
        break;
      case /ing/.test(str):
        display("• Matched 'ing' test");
        break;
      default:
        display("• Didn't match any test");
        break;
    }
}

Это работает из-за того, как switchработают операторы JavaScript , в частности два ключевых аспекта: во-первых, случаи рассматриваются в порядке исходного текста , и во-вторых, что выражения селектора (биты после ключевого слова case) являются выражениями , которые оцениваются как этот случай. оценивается (не константы, как в некоторых других языках). Так как наше тестовое выражение имеет значение true, первое caseвыражение, которое приводит к получению, trueбудет тем, которое будет использовано.

RegExp может использоваться для входной строки не только технически, но и практически вместе с matchметодом.

Поскольку выходные данные match()являются массивом, нам нужно получить первый элемент массива результата. Когда совпадение не удается, функция возвращается null. Чтобы избежать ошибки исключения, мы добавим ||условный оператор перед доступом к первому элементу массива и проверим inputсвойство , являющееся статическим свойством регулярных выражений, которое содержит строку ввода.

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()конструктора для преобразования результирующего массива, который должен иметь только 1 элемент (без групп захвата), и всю строку необходимо захватывать с помощью квантификаторов ( .*) в строку. В случае сбоя nullобъект станет "null"строкой. Не удобно.

str = 'haystack';
switch (str) {
  case String(str.match(/^hay.*/)):
    console.log("Matched a string that starts with 'hay'");
    break;
}

В любом случае, более элегантным решением является использование метода /^find-this-in/.test(str)with, switch (true)который просто возвращает логическое значение, и его легче искать без учета регистра.

Просто используйте свойство location.host

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

Другой вариант - использовать inputполе результата соответствия регулярному выражению :

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

var token = 'spo';

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

-> Если сопоставление установлено, троичное выражение возвращает исходный токен
----> Исходный токен оценивается регистром

-> Если совпадение не выполнено, троичное возвращает неопределенное значение
----> Кейс сравнивает токен с неопределенным, что, как мы надеемся, не является вашим токеном.

Тройной тест может быть чем угодно, например, в вашем случае

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

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

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

это троичное выражение.

Тест в этом случае - token.match (/ spo /), который устанавливает соответствие строки, содержащейся в токене, с выражением регулярного выражения / spo / (в данном случае это буквальная строка spo).

Если выражение и строка соответствуют, это приводит к истине и возвращает токен (то есть строку, над которой работает оператор switch).

Очевидно, токен === токен, так что оператор switch совпадает, а регистр вычисляется

Проще понять, если вы посмотрите на него послойно и поймете, что тест Turnery оценивается «ДО» оператора switch, так что оператор switch видит только результаты теста.

Это может быть проще. Попробуйте подумать так:

• сначала поймать строку между обычными символами
• после этого найдите «дело»

:

// '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

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

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

Вы можете продолжить, передать список параметров и обработать регулярное выражение с помощью |