Instruction pour la chaîne correspondante en JavaScript Switch

Question

Comment puis-je écrire un swtich pour le conditionnel suivant ?

Si l’url contient « foo », alors settings.base_url est « bar ».

Ce qui suit est atteindre l’effet requis, mais j’ai le sentiment que ce serait plus facile à gérer dans un commutateur :

Answer 1

Vous ne pouvez pas le faire dans un switch sauf si vous faites complet correspondance de chaîne; c'est faire en sous-chaîne correspondant. (Ce n'est pas tout à fait vrai, comme Sean points dans les commentaires. Voir la note à la fin.)

Si vous êtes satisfait de votre regex en haut est le dépouiller de tout ce que vous ne voulez pas de comparer à votre match, vous n'avez pas besoin d'une correspondance de sous-chaîne, et pourrait faire:

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

...mais encore une fois, cela ne fonctionne que si le complet de la chaîne que vous êtes correspondant. Il ne pourrait pas s' base_url_string ont été, disons, "yyy.xxx.locaux", alors que votre code correspond à celui de la "xxx.locaux" de la branche.

---

Mise à jour: Ok, donc techniquement, vous pouvez utiliser un switch pour la sous-chaîne correspondant, mais je ne le recommande pas, dans la plupart des situations. Voici comment (live exemple):

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

Qui fonctionne en raison de la façon JavaScript switch des énoncés des travaux, en particulier deux aspects essentiels: d'Abord, que les cas sont à considérer dans le texte de la source de l'ordre, et, deuxièmement, que le sélecteur d'expressions (les bits après le mot-clé case) sont des expressions qui sont évaluées comme ce cas est évalué (pas constantes comme dans quelques autres langues). Depuis notre test d'expression est - true, la première case expression des résultats en true sera celle qui est utilisée.

Answer 2

RegExp peut être utilisé sur la chaîne d'entrée, pas seulement techniquement, mais pratiquement, avec l' match méthode de trop.

Parce que la sortie de l' match() est un tableau que nous avons besoin de récupérer le premier élément du tableau est le résultat. Quand le match échoue, la fonction retourne null. Pour éviter une erreur d'exception lorsque l'accès à un élément du tableau est null nous joindre les regexp dans une option de capture d'un groupe.

Si l'expression rationnelle échoue, la sortie de l' str.match(/(find)?/)[1] sera undefined et si elle réussit, elle sera égale à str.

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

Une autre approche consiste à utiliser l' String() constructeur de convertir le tableau résultant qui a juste 1 élément d'une chaîne de caractères. En cas de défaillance de l' null objet deviendra un "null" chaîne de caractères. Dans ce cas, il n'y a pas besoin de l'option capture d'un groupe.

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

De toute façon, une solution plus élégante consiste à utiliser l' /^find-this-in/.test(str) méthode qui renvoie une valeur booléenne. Et il y a un autre avantage est que la désactivation de la casse est aussi facile que d'ajouter de l' i modificateur à la regexp, au lieu d'utiliser toLowerCase() avec l' match méthode

Answer 3

Il suffit d’utiliser la propriété location.host

Answer 4

Une autre option consiste à utiliser `` champ d’un résultat de match de regexp:

Answer 5

var token = 'spo';

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

--> Si le match est fait le ternaire expression renvoie le jeton d'origine
----> L'original jeton est évaluée par cas

--> Si le match n'est pas fait le ternaire renvoie undefined
----> De cas évalue le jeton contre indéfini qui nous l'espérons, votre jeton n'est pas.

Le ternaire test peut être n'importe quoi, par exemple dans votre cas

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

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

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

est une expression ternaire.

Le test dans ce cas est de jeton.match(/spo/) qui stipule que le match de la chaîne tenu à jeton à l'encontre de l'expression regex /spo/ ( qui est la chaîne spo dans ce cas ).

Si l'expression et de la chaîne d'égaler les résultats dans le vrai et retourne un jeton ( qui est la chaîne de l'instruction switch est en fonctionnement ).

Évidemment token === token donc l'instruction de commutation est adapté et le cas évalués

Il est plus facile à comprendre si vous regardez dans les couches et de comprendre que le tournage de test est évalué "AVANT" l'instruction de commutation de sorte que l'instruction switch ne voit que les résultats du test.