Activer des plages d'entiers en JavaScript
Je veux faire quelque chose comme ça
switch (this.dealer) {
case 1-4:
// Do something.
break;
case 5-8:
// Do something.
break;
case 9-11:
// Do something.
break;
default:
break;
}
Quelle est la bonne syntaxe pour cela? Est-ce possible en JavaScript?
Alors this.dealer est un entier, et si c'est entre ces valeurs, faites quelque chose.
Voici une autre façon je l'ai compris:
const x = this.dealer;
switch (true) {
case (x < 5):
alert("less than five");
break;
case (x < 9):
alert("between 5 and 8");
break;
case (x < 12):
alert("between 9 and 11");
break;
default:
alert("none");
break;
}
Incrémenter la réponse de MarvinLabs pour le rendre plus propre:
var x = this.dealer;
switch (true) {
case (x < 5):
alert("less than five");
break;
case (x < 9):
alert("between 5 and 8");
break;
case (x < 12):
alert("between 9 and 11");
break;
default:
alert("none");
break;
}
Il n’est pas nécessaire de vérifier la limite inférieure de la plage car les instructions break forceront l’exécution à ignorer les cas restants. Ainsi, au moment de l’exécution, le contrôle, par exemple, (x <9) nous savons que la valeur doit être égale ou supérieure à 5.
Bien sûr, la sortie n'est correcte que si les cas restent dans l'ordre d'origine, et nous supposons des valeurs entières (comme indiqué dans la question) - techniquement, les plages sont comprises entre 5 et 8,999999999999 ou à peu près, car tous les nombres de js sont en réalité des nombres flottants à double précision. numéros de points.
Si vous voulez pouvoir déplacer les requêtes ou trouver plus lisible d'avoir la gamme complète visible dans chaque instruction de requête, il vous suffit d'ajouter une vérification de valeur inférieure ou égale à la gamme inférieure de chaque requête:
var x = this.dealer;
switch (true) {
case (x < 5):
alert("less than five");
break;
case (x >= 5 && x < 9):
alert("between 5 and 8");
break;
case (x >= 9 && x < 12):
alert("between 9 and 11");
break;
default:
alert("none");
break;
}
Gardez à l'esprit que cela ajoute un point d'erreur humaine supplémentaire - quelqu'un peut essayer de mettre à jour une plage, mais oubliez de la changer aux deux endroits, en laissant un chevauchement ou un espace qui n'est pas couvert. par exemple. ici le cas de 8 ne correspondra plus à rien si je modifie simplement le cas qui correspondait à 8.
case (x >= 5 && x < 8):
alert("between 5 and 7");
break;
case (x >= 9 && x < 12):
alert("between 9 and 11");
break;
switch(this.dealer) {
case 1:
case 2:
case 3:
case 4:
// Do something.
break;
case 5:
case 6:
case 7:
case 8:
// Do something.
break;
default:
break;
}
Si vous n'aimez pas la succession des cas, optez simplement pour if/else if/else déclarations.
Ceci ne nécessite pas une instruction switch. Il est beaucoup plus clair , plus concis et plus rapide pour utiliser simplement les instructions if else ...
var d = this.dealer;
if (1 <= d && d <= 11) { // making sure in range 1..11
if (d <= 4) {
alert("1 to 4");
} else if (d <= 8) {
alert("5 to 8");
} else {
alert("9 to 11");
}
} else {
alert("not in range");
}
Test de vitesse
J'étais curieux de savoir ce qu'il en coûterait d'utiliser un commutateur au lieu de l'option la plus simple si ... sinon ..., j'ai donc monté un jsFiddle pour l'examiner ... http://jsfiddle.net/17x9w1eL/
Chrome: switch était environ 70% plus lent que si autre
Firefox: switch était environ 5% plus lent que si autre
IE: switch était environ 5% plus lent que si autre
Safari: switch était environ 95% plus lent que si autre
Notes:
L'affectation à la variable locale est facultative, surtout si votre code sera optimisé automatiquement ultérieurement.
Pour les gammes numériques, j'aime utiliser ce type de construction ...
if (1 <= d && d <= 11) {...}
... parce que pour moi, cela lit plus près de la façon dont vous exprimeriez une plage en maths (1 <= d <= 11), et quand je lis le code, je peux le lire comme "si d est compris entre 1 et 11 ".
plus clair
Quelques personnes ont fait remarquer qu'elles ne pensaient pas que cela soit plus clair. Ce n'est certainement pas moins clair car la structure est presque identique à l'option de commutation. La raison principale pour laquelle est plus clair est que chaque partie est lisible et a un sens intuitif simple, alors que "switch (true)" est une ligne plutôt dépourvue de sens. de code. Beaucoup de codeurs, lisant cela dans votre script, vont dire "WTF, ça veut dire quoi?" et ensuite avoir à le chercher. C'est un sale coup, ce n'est pas intuitif et ce n'est pas clair. Si c'est comme ça que vous aimez coder, et que personne d'autre n'aura à gérer votre base de code, continuez, sinon, il est préférable d'utiliser les constructions à quoi elles sont destinées.
Si vous avez besoin de plages de vérification, vous êtes probablement mieux avec if et else if _ déclarations, comme ceci:
if (range > 0 && range < 5)
{
// ..
}
else if (range > 5 && range < 9)
{
// ..
}
else
{
// Fall through
}
Un interrupteur peut devenir grand sur de plus grandes gammes.
Non, ce n'est pas possible. Le plus proche que vous pouvez obtenir est:
switch(this.dealer) {
case 1:
case 2:
case 3:
case 4:
// DO SOMETHING
break;
case 5:
case 6:
case 7:
case 8:
// DO SOMETHING
break;
Mais cela très difficilement.
Dans de tels cas, il vaut généralement mieux utiliser un if/else if structure.
function sequentialSizes(val) {
var answer = "";
switch (val){
case 1:
case 2:
case 3:
case 4:
answer="Less than five";
break;
case 5:
case 6:
case 7:
case 8:
answer="less than 9";
break;
case 8:
case 10:
case 11:
answer="More than 10";
break;
}
return answer;
}
// Change this value to test you code to confirm ;)
sequentialSizes(1);
Si vous essayez de faire quelque chose de rapide, efficace et lisible, utilisez une norme si ... alors ... sinon structure comme ceci:
var d = this.dealer;
if (d < 12) {
if (d < 5) {
alert("less than five");
}else if (d < 9) {
alert("between 5 and 8");
}else{
alert("between 9 and 11");
}
}else{
alert("none");
}
Si vous voulez le masquer et le rendre affreux (mais petit), essayez ceci:
var d=this.dealer;d<12?(d<5?alert("less than five"):d<9?alert("between 5 and 8"):alert("between 9 and 11")):alert("none");
BTW, le code ci-dessus est un JavaScript si ... alors ... autre déclaration abrégée. C’est un excellent exemple de la façon dont il est interdit d’écrire du code à moins que l’objectif soit l’obfuscation ou la minification de code. Sachez que la maintenance du code peut être un problème si elle est écrite de cette façon. Très peu de gens peuvent facilement le lire, voire pas du tout. La taille du code est toutefois 50% plus petite que la norme si ... alors ... sinon sans perte de performance. Cela signifie que dans des bases de code plus grandes, une minification comme celle-ci peut considérablement accélérer la livraison du code sur des réseaux à bande passante limitée ou à latence élevée.
Ceci, cependant, ne devrait pas être considéré comme une bonne réponse. C'est juste un exemple de ce qui peut être fait, pas ce qui DEVRAIT être fait.
Une version plus lisible du ternaire pourrait ressembler à ceci:
var x = this.dealer;
alert(t < 1 || t > 11
? 'none'
: t < 5
? 'less than five'
: t <= 8
? 'between 5 and 8'
: 'Between 9 and 11');