tipos - split javascript

Declaración de cambio para la coincidencia de cadenas en JavaScript

Question

¿Cómo escribo un swtich para el siguiente condicional?

Si la url contiene "foo", entonces settings.base_url es "bar".

Lo siguiente es lograr el efecto requerido, pero tengo la sensación de que esto sería más manejable en un cambio:

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

Answer 1

Otra opción es usar input campo de input de un resultado de coincidencia de expresiones regulares :

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

Answer 2

Podría ser demasiado tarde y todo, pero me gustó esto en caso de asignación :)

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

podría llevarlo más allá, pasar una lista de opciones y manejar la expresión regular con |

Answer 3

Puede ser más fácil. Intenta pensar así:

• primero atrapa una cadena entre caracteres regulares
• después de eso, encuentra "caso"

:

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

Answer 4

RegExp se puede utilizar en la cadena de entrada no solo técnicamente sino también prácticamente con el método de match .

Como el resultado de la match() es una matriz, necesitamos recuperar el primer elemento de matriz del resultado. Cuando falla la coincidencia, la función devuelve null . Para evitar un error de excepción, agregaremos || operador condicional antes de acceder al primer elemento de matriz y probar contra la propiedad de input que es una propiedad estática de expresiones regulares que contiene la cadena de entrada.

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

Otro enfoque es utilizar el constructor String() para convertir la matriz resultante que debe tener solo 1 elemento (sin grupos de captura) y toda la cadena debe capturarse con los calificadores ( .* ) En una cadena. En caso de falla, el objeto null se convertirá en una cadena "null" . No conveniente.

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

De todos modos, una solución más elegante es usar el /^find-this-in/.test(str) con switch (true) que simplemente devuelve un valor booleano y es más fácil buscar sin mayúsculas y minúsculas.

Answer 5

Solo use la propiedad location.host

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

Answer 6

No puede hacerlo en un switch menos que esté haciendo una coincidencia completa de cadenas; eso es hacer coincidencia de subcadenas . (Esto no es del todo cierto, como señala Sean en los comentarios. Ver nota al final).

Si está contento de que su expresión regular en la parte superior esté eliminando todo lo que no quiere comparar en su partida, no necesita una coincidencia de subcadenas, y podría hacer:

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

... pero de nuevo, eso solo funciona si esa es la cadena completa que estás buscando. base_url_string si base_url_string fuera, por ejemplo, "yyy.xxx.local" mientras que su código actual coincidiría con el de la rama "xxx.local".

Actualización : Bien, técnicamente puede usar un switch para la coincidencia de subcadenas, pero no lo recomendaría en la mayoría de las situaciones. Así es como ( ejemplo en vivo ):

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

Eso funciona debido a la forma en que funcionan las instrucciones de switch JavaScript, en particular dos aspectos clave: primero, que los casos se consideran en el orden del texto fuente y segundo que las expresiones del selector (los bits después del case palabra clave) son expresiones que se evalúan como el caso se evalúa (no constantes como en otros idiomas). Entonces, como nuestra expresión de prueba es true , la primera expresión de case que resulte true será la que se use.

Answer 7

var token = ''spo'';

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

-> Si la coincidencia se realiza, la expresión ternaria devuelve el token original
----> El token original se evalúa por caso

-> Si la coincidencia no se realiza, el ternario devuelve indefinido
----> Case evalúa el token contra indefinido, lo que esperamos que tu token no lo haga.

La prueba ternaria puede ser cualquier cosa, por ejemplo, en su caso

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

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

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

es una expresión ternaria.

La prueba en este caso es token.match (/ spo /) que establece la coincidencia de la cadena contenida en el token con la expresión regular / spo / (que en este caso es la cadena literal spo).

Si la expresión y la cadena coinciden, da como resultado verdadero y devuelve el token (que es la cadena en la que está operando la instrucción switch).

Obviamente token === token por lo que la instrucción switch se corresponde y el caso evaluado

Es más fácil de entender si lo mira por capas y entiende que la prueba de torneado se evalúa "ANTES" de la declaración de cambio de modo que la instrucción de cambio solo vea los resultados de la prueba.