Expresión switch versus sentencia switch

Cuando se escribe código con muchas condiciones, seguramente has usado tanto una sentencia if-else como una sentencia switch. Pero esta alternativa a if-else tiene sus inconvenientes. Algunas personas incluso han llamado a la sentencia switch un "anti-patrón".

Pero hay buenas noticias: nuevas versiones de Java han traído muchos cambios en la sintaxis del lenguaje, y uno de esos cambios afecta a switch. ¿Intrigado? Entonces, ¡vamos a sumergirnos!

Para empezar, vale la pena aclarar por qué la sentencia switch es un anti-patrón. Considera el siguiente código:

switch (condition) {
    case "DECEMBER":
        seasonNumber = 1;
        break;
    case "JANUARY":
        seasonNumber = 1;
        break;
    case "FEBRUARY":
        seasonNumber = 1;
        break;
    default:
        seasonNumber = 0;
}

Vale, aún no está del todo claro por qué esto es un "anti-patrón".

Pero, ¿qué pasa si agregamos más bloques case y ahora el código se ve así?

switch (condition) {
    case "DECEMBER":
        seasonNumber = 1;
        break;
    case "JANUARY":
        seasonNumber = 1;
        break;
    case "FEBRUARY":
        seasonNumber = 1;
        break;
    case “MARCH”:
        seasonNumber = 2;
        break;
    case “APRIL”:
        seasonNumber = 2;
        break;
    case “MAY”:
        seasonNumber = 2;
        break;
    default:
        seasonNumber = 0;
}

Agreguemos algunas líneas más, el código se hace más largo. Luego podemos agregar más y más líneas, y nadie nos detendrá para hacer esto.

Este es el corazón del problema: después de crear inicialmente una sentencia switch compacta, agregamos más y más código, ocupando más y más espacio - más de lo que cabe en la pantalla - y haciendo que el código sea incómodo de leer y mantener.

Diferencia entre la sentencia switch y la expresión switch

Java 14 introdujo un nuevo y mejorado switch. No es una sentencia switch, sino una expresión switch.

¿Cuál es la diferencia, preguntas? La diferencia es que una sentencia es una instrucción que realiza un conjunto determinado de operaciones, pero una expresión es un fragmento de código que realiza algún cálculo y devuelve un resultado.

En otras palabras, ahora puedes guardar el resultado de un switch en una variable.

Suficiente charla. Ahora veamos cómo es el nuevo switch:

var result = switch(month) {
     case DECEMBER, JANUARY, FEBRUARY -> 1;
     case MARCH, APRIL, MAY -> 2;
    case JUNE, JULY, AUGUST -> 3;
    case SEPTEMBER, OCTOBER, NOVEMBER -> 4;
    default -> 0;
};

Lo primero que llama la atención es lo compacto que es el código. El código que solía ocupar la mayor parte de la pantalla ahora ocupa unas pocas líneas y se ve mucho más legible.

Operador ->

También debes tener en cuenta el operador -> (operador flecha). Es posible que ya estés familiarizado con él si tienes experiencia con las expresiones lambda.

Esto significa que ahora puedes escribir un switch con un aspecto interesante en el estilo de una expresión lambda. El operador de flecha indica que el compilador no avanzará hacia la siguiente expresión case (si el bloque case actual carece de una sentencia break o return), sino que en su lugar te dará el valor de la expresión a la derecha de la flecha.

También puedes escribir código que no es una expresión y simplemente realiza ciertas acciones en lugar de devolver algo:

switch(condition) {
    case TRUE, FALSE -> System.out.println("True/false");

    default -> System.out.println("Another");
}

Ten en cuenta que la sentencia switch ya no tiene una sentencia break. Fue eliminada en Java 13 y reemplazada por yield.

¿Qué es yield y dónde se puede usar?

Cuando un switch consiste en una sola línea, el operador -> en sí mismo devuelve el valor. ¿Pero qué pasa si tenemos no una, sino muchas líneas de código? En esos casos, el operador de flecha no devolverá un valor, ya que hay múltiples líneas, no una sola.

¿Quizás podemos usar return? Después de todo, se usa para devolver valores en Java. Pero no, return no funciona con un switch. Entonces, ¿qué podemos usar? Solía haber break, pero eso fue eliminado en Java 13. Pero en su lugar ahora tenemos yield: una nueva palabra clave que te ayuda a devolver un valor desde un switch. Es análogo a las sentencias return en los métodos.

var result = switch(condition) {
//…
case "Hi" -> "greeting"
//…
};

Este código contiene una sola línea, y el operador -> devolverá "saludo".

Pero cuando tenemos un bloque de código:

var result = switch(condition) {
//…
case "Hi" -> {
// Your code
 Here you need to return "greeting"
	}
};

La palabra clave que te ayudará a devolver un valor es yield:

var result = switch(condition) {
//…
case "Hi" -> {
// Your code
 yield "greeting";

	}
};

yield fue agregado en Java 13 para casos en los que tenemos más de una línea de código en un bloque case y necesitamos devolver un resultado.

Probablemente estés ansioso por probar el nuevo switch en tu código, pero recuerda que necesitas Java 14 o superior para hacer esto. Con versiones anteriores, este switch solo estará disponible si especificas la bandera "--enable-preview" en la línea de comandos, ya que antes de la versión 14 era parte de la vista previa técnica, no una parte plenamente integrada del lenguaje.

¡Eso es todo por ahora! ¡Hasta pronto!