Polecenie Switch do dopasowania łańcuchów w JavaScript

RegExp może być użyty na łańcuchu wejściowym nie tylko technicznie, ale i praktycznie za pomocą metody match.

Ponieważ wyjście match() jest tablicą, musimy pobrać pierwszy element tablicy wyniku. Gdy dopasowanie nie powiedzie się, funkcja zwraca null. Aby uniknąć błędu wyjątku, dodamy operator warunkowy || przed uzyskaniem dostępu do pierwszego elementu tablicy i przetestujemy właściwości input , które są statyczną właściwością wyrażeń regularnych, które zawiera łańcuch wejściowy.

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

Innym sposobem jest użycie konstruktora String() do konwersji wynikowej tablicy, która musi mieć tylko 1 element (bez grup przechwytywania) i cały łańcuch musi być przechwytywany za pomocą quanitifiers (.*) na łańcuch. W przypadku niepowodzenia obiekt null stanie się ciągiem znaków "null". To nie jest wygodne.

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

W każdym razie, bardziej eleganckim rozwiązaniem jest użycie metody /^find-this-in/.test(str) z switch (true), która po prostu zwraca wartość logiczną i łatwiej jest wyszukiwać bez wielkość liter.

Po prostu użyj lokalizacji.host property

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

Inną opcją jest użycie pola {[1] } z regexp match result :

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

--> Jeśli dopasowanie zostanie wykonane, wyrażenie trójskładnikowe zwróci oryginalny token
----> oryginalny token jest oceniany przez case

-- > Jeśli dopasowanie nie jest wykonane, Trójnik zwraca undefined
----> Case ocenia token na undefined, który, miejmy nadzieję, nie jest Twoim tokenem.

Test trójkowy może być dowolny, na przykład w Twoim przypadku

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

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

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

Jest wyrażeniem trójdzielnym.

Test w tym przypadku jest token.match (/spo/), który określa dopasowanie łańcucha przechowywanego w tokenie do wyrażenia regex/ spo / (które w tym przypadku jest literalnym łańcuchem spo).

Jeśli wyrażenie i łańcuch są zgodne, to powoduje to true i zwraca token(który jest łańcuchem, na którym operuje Instrukcja switch).

Oczywiście token = = = token więc polecenie switch jest dopasowane i wielkość liter

Jest łatwiej zrozumieć, jeśli spojrzeć na to w warstwy i zrozumieć, że test turnery jest oceniany "przed" instrukcją switch tak, że instrukcja switch widzi tylko wyniki testu.

Może być łatwiej. Spróbuj tak myśleć:

• najpierw Złap łańcuch pomiędzy zwykłymi znakami
• po tym znajdź "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

Może być za późno i w ogóle, ale mi się to podobało w przypadku:)

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

Event może pójść dalej, przekazać listę opcji i obsłużyć regex za pomocą /