validar - ¿Cómo puedo usar rangos en una declaración de mayúsculas y minúsculas usando JavaScript?

validar alfanumerico javascript

Question

¿Cómo puedo usar rangos en una declaración de mayúsculas y minúsculas usando JavaScript? Entonces, en lugar de escribir código para todas y cada una de las posibilidades, me gustaría agruparlas en rangos, por ejemplo:

switch(myInterval){
case 0-2:
//doStuffWithFirstRange();
break;
case 3-6:
//doStuffWithSecondRange();
break;
case 6-7:
//doStuffWithThirdRange();
break;
default:
//doStuffWithAllOthers();
}

Answer 1

¿Es esto tal vez lo que necesitas?

switch(myInterval){
case 0:
case 1:
case 2:
//doStuff();
break;
case 3:
case 4:
case 5:
case 6:
//doStuff();
break;
case 6:
case 7:
//doStuff();
break;
default:
//doStuff();
}

Si sabe que el rango va a ser muy alto (por ejemplo 0-100 ) también puede hacer esto, que seguramente es más fácil, más limpio y más simple:

if (myInterval >= 0 && myInterval <= 20) {
//doStuff();
} else if (myInterval > 20 && myInterval <= 60) {
//doStuff();
} else if (myInterval > 60 && myInterval <= 70) {
//doStuff();
} else /* it is greater than 70 */ {
//doStuff();
}

Answer 2

Los rangos en este ejemplo son bastante pequeños, pero así es como se pueden manejar rangos más grandes, según los documentos de JavaScript MDN :

// The value we''ll be evaluating:
let code = 100;
// Matches for any case where the expression === `true`:
switch (true) {
case code <= 64:
return "Your number is 64 or less!";
break;
case code >= 65 && code <= 90:
return "Your number is in the range of 65-90!";
break;
case code >= 97 && code <= 122:
return "Your number is in the range of 97-122!";
break;
case code >= 123:
return "Your number is 123 or greater!";
break;
default:
break;
}

Sé que este estilo ya fue mostrado por TJ Crowder a través de Use case with Expressions , pero solo quería mostrar otro ejemplo de cómo utilizar este mismo método. Simplemente hice esto y pensé que tal vez otro ejemplo podría ayudar a alguien, ya que todavía estaba un poco confundido después de leer otras respuestas.

Answer 3

Si sus rangos son los mismos y comienzan desde 0, puede hacer algunas operaciones matemáticas.

doStuffWithRange(Math.floor(myInterval/range));

Por ejemplo, si quiere ROJO, VERDE y AZUL en el mapa como en su ejemplo:

• Rango 0-2 se asigna a RED
• Rango 3-6 mapas a VERDE
• Rango 7-8 mapas a AZUL

Puedes escribir:

function colorInterval(n, max) {
var colors = ["RED", "GREEN", "BLUE"];
var range = max/colors.length
return colors[Math.floor(n/range)];
}
//You get 3 of RED, 3 of GREEN, 2 of BLUE
for (var i=0; i<8; i++) {
console.log(colorInterval(i, 8));
}

Tenga en cuenta que el último rango en el ejemplo es 2, no 3 y esto sigue funcionando mientras los rangos anteriores sean los mismos.

Answer 4

Use la declaración de caso con cadena o valor definido o use "if else if", en caso de que el rango sea mayor

Answer 5

Usted tiene al menos cuatro opciones:

1. Haz una lista de cada case

Como se muestra en LightStyle , puede enumerar cada caso de forma explícita:

switch(myInterval){
case 0:
case 1:
case 2:
doStuffWithFirstRange();
break;
case 3:
case 4:
case 5:
doStuffWithSecondRange();
break;
case 6:
case 7:
doStuffWithThirdRange();
break;
default:
doStuffWithAllOthers();
}

2. Use if / else if / else

Si los rangos son grandes, eso se vuelve difícil de manejar, por lo que querrá hacer rangos. Tenga en cuenta que con if...else if...else if , no llega a los posteriores si coincide uno anterior, por lo que solo debe especificar el límite superior cada vez. /*...*/ límite inferior en /*...*/ para mayor claridad, pero normalmente lo /*...*/ para evitar introducir un problema de mantenimiento (si incluyes ambos límites, es fácil cambiar uno y olvidar cambiar el otro) :

if (myInterval < 0) {
// I''m guessing this is an error
}
else if (/* myInterval >= 0 && */ myInterval <= 2){
doStuffWithFirstRange();
}
else if (/* myInterval >= 3 && */ myInterval <= 5) {
doStuffWithSecondRange();
}
else if (/* myInterval >= 6 && */ myInterval <= 7) {
doStuffWithThirdRange();
}
else {
doStuffWithAllOthers();
}

3. case uso con expresiones:

JavaScript es inusual en el sentido de que puede usar expresiones en el enunciado de case , por lo que podemos escribir la secuencia if...else if...else if arriba como una instrucción switch :

switch (true){
case myInterval < 0:
// I''m guessing this is an error
break;
case /* myInterval >= 0 && */ myInterval <= 2:
doStuffWithFirstRange();
break;
case /* myInterval >= 3 && */ myInterval <= 5:
doStuffWithSecondRange();
break;
case /* myInterval >= 6 && */ myInterval <= 7:
doStuffWithThirdRange();
break;
default:
doStuffWithAllOthers();
}

No estoy abogando por eso, pero es una opción en JavaScript, y hay momentos en que es útil. Las declaraciones de case se verifican en orden con respecto al valor que das en el switch . (Y de nuevo, los límites inferiores podrían omitirse en muchos casos porque habrían coincidido antes). Aunque los case se procesan en orden de código fuente, el default puede aparecer en cualquier lugar (no solo al final) y solo se procesa si ya sea que no coincida ningún case o que haya un case coincidente y haya caído en el valor predeterminado (no hubo break , es raro que quiera hacer eso, pero sucede).

4. Use un mapa de despacho

Si todas sus funciones toman los mismos argumentos (y eso podría no ser argumentos, o simplemente los mismos), otro enfoque es un mapa de despacho:

En algunos códigos de configuración:

var dispatcher = {
0: doStuffWithFirstRange,
1: doStuffWithFirstRange,
2: doStuffWithFirstRange,
3: doStuffWithSecondRange,
4: doStuffWithSecondRange,
5: doStuffWithSecondRange,
6: doStuffWithThirdRange,
7: doStuffWithThirdRange
};

Luego, en lugar del interruptor:

(dispatcher[myInterval] || doStuffWithAllOthers)();

Eso funciona al buscar la función para llamar al mapa del doStuffWithAllOthers , por defecto a doStuffWithAllOthers si no hay entrada para ese valor específico de myInterval usando el curiosamente poderoso || operador , y luego llamarlo.

Puedes dividir eso en dos líneas para hacerlo un poco más claro:

var f = dispatcher[myInterval] || doStuffWithAllOthers;
f();

He usado un objeto para la máxima flexibilidad. Puede definir el dispatcher esta manera con su ejemplo específico:

var dispatcher = [
/* 0-2 */
doStuffWithFirstRange,
doStuffWithFirstRange,
doStuffWithFirstRange,
/* 3-5 */
doStuffWithSecondRange,
doStuffWithSecondRange,
doStuffWithSecondRange,
/* 6-7 */
doStuffWithThirdRange,
doStuffWithThirdRange
];

... pero si los valores no son números contiguos, es mucho más claro usar un objeto en su lugar.

Answer 6

int levelNumber = YOUR_VALUE FROM

NSString* strMessage;
switch (levelNumber) {
case 1 ... 10:
{
// Do something...
break;
}
case 11 ... 20:
{
// Do something...
break;
}
case 21 ... 30:
{
// Do something...
break;
}
case 31 ... 40:
{
// Do something...
break;
}
default:
break;
}