instruction switch | changer d'expression

Lorsque vous écrivez du code avec de nombreuses conditions, vous avez sûrement utilisé une instruction if-else ou une instruction switch . Mais cette alternative au if-else a des inconvénients. Certaines personnes ont même qualifié l' instruction switch d'"anti-pattern".

Mais il y a de bonnes nouvelles : les nouvelles versions de Java ont apporté de nombreux changements dans la syntaxe du langage, et l'un de ces changements affecte switch . Intrigué ? Alors allons plonger.

Pour commencer, il convient de clarifier pourquoi le switch est un anti-pattern. Considérez le code suivant :

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

D'accord, la raison pour laquelle il s'agit d'un "anti-modèle" n'est pas encore tout à fait claire.

Mais que se passe-t-il si nous ajoutons plus de blocs de cas et maintenant le code ressemble à ceci :

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

Ajoutons quelques lignes supplémentaires - le code s'allonge. Plus tard, nous pourrons ajouter de plus en plus de lignes, et personne ne nous empêchera de le faire.

C'est le cœur du problème : après avoir initialement créé une instruction switch compacte, nous y ajoutons de plus en plus de code, occupant de plus en plus d'espace - plus que ce qui peut tenir sur l'écran - et rendant le code peu pratique à lire et à entretenir.

Différence entre l'instruction switch et l'expression switch

Java 14 a introduit un nouveau commutateur amélioré. Ce n'est pas une instruction switch , mais plutôt une expression switch .

Quelle est la différence, demandez-vous? La différence est qu'une instruction est une instruction qui effectue un certain ensemble d'opérations, mais une expression est un morceau de code qui effectue un calcul et renvoie un résultat.

En d'autres termes, vous pouvez désormais enregistrer le résultat d'un basculement vers une variable.

Assez parlé. Voyons maintenant à quoi ressemble le nouveau commutateur :

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

La première chose qui attire votre attention est la compacité du code. Le code qui occupait la majeure partie de l'écran s'étend maintenant sur quelques lignes et semble beaucoup plus lisible.

-> opérateur

Vous devez également noter l' opérateur -> (opérateur flèche). Vous le connaissez peut-être déjà si vous avez de l'expérience avec les expressions lambda.

Cela signifie que vous pouvez maintenant écrire un commutateur d'apparence cool dans le style d'une déclaration lambda. L'opérateur de flèche indique que le compilateur ne passera pas à l' expression de cas suivante (si le bloc de cas actuel n'a pas d' instruction break ou return ), mais vous donnera à la place la valeur de l'expression à droite de la flèche.

Vous pouvez également écrire du code qui n'est pas une expression et effectue simplement certaines actions au lieu de renvoyer quoi que ce soit :

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

Notez que switch n'a plus d' instruction break . Il a été supprimé dans Java 13 et remplacé par yield .

Qu'est-ce que le rendement et où peut-il être utilisé ?

Lorsqu'un commutateur se compose d'une seule ligne, l' opérateur -> lui-même renvoie la valeur. Mais que se passe-t-il si nous n'avons pas une, mais plusieurs lignes de code ? Dans de tels cas, l'opérateur flèche ne renverra pas de valeur, car il y a plusieurs lignes, pas une.

Peut-être pouvons-nous utiliser return ? Après tout, il est utilisé pour renvoyer des valeurs en Java. Hélas, non, le retour ne fonctionnera pas avec un interrupteur. Alors que pouvons-nous utiliser ? Auparavant, il y avait break , mais cela a été supprimé dans Java 13. Mais à sa place, nous avons maintenant yield - un nouveau mot-clé qui vous aide à renvoyer une valeur à partir d'un commutateur. Il est analogue aux déclarations de retour dans les méthodes.

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

Ce code contient une seule ligne, et l' opérateur -> renverra "salut".

Mais quand on a un bloc de code :

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

Le mot-clé qui vous aidera à retourner une valeur est yield :

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

	}
};

yield a été ajouté dans Java 13 pour les cas où nous avons plus d'une ligne de code dans un bloc case et nous devons renvoyer un résultat.

Vous êtes probablement impatient d'essayer le nouveau commutateur dans votre code, mais n'oubliez pas que vous avez besoin de Java 14 ou supérieur pour le faire. Avec les versions antérieures, ce commutateur ne sera disponible que si vous spécifiez l'indicateur "--enable-preview" sur la ligne de commande, car avant la version 14, il faisait partie de l'aperçu technique, et non d'une partie à part entière du langage.

C'est tout pour le moment! À bientôt!