Skift udtryk versus switch-sætning

Når du skriver kode med en masse betingelser, har du helt sikkert brugt enten en if-else eller en switch- sætning. Men dette alternativ til if-else har ulemper. Nogle mennesker har endda kaldt switch- erklæringen for et "anti-mønster".

Men der er gode nyheder: Nye versioner af Java har medført en masse ændringer i sprogets syntaks, og en af ​​disse ændringer påvirker switch . fascineret? Så lad os dykke ind.

Til at begynde med er det værd at afklare, hvorfor switch er et anti-mønster. Overvej følgende kode:

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

Okay, så det er endnu ikke helt klart, hvorfor dette er et "anti-mønster".

Men hvad nu hvis vi tilføjer flere sagsblokke og nu ser koden sådan ud:

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

Lad os tilføje et par linjer mere - koden bliver længere. Senere kan vi tilføje flere og flere linjer, og ingen vil forhindre os i at gøre dette.

Dette er problemets kerne: Efter at have oprettet en kompakt switch -erklæring, tilføjer vi mere og mere kode til den, og optager mere og mere plads - mere end der er plads til på skærmen - og gør koden ubelejlig at læse og vedligeholde.

Forskellen mellem switch-sætningen og switch-udtrykket

Java 14 introducerede en ny og forbedret switch. Det er ikke en switch-sætning , men derimod et switch-udtryk .

Hvad er forskellen, spørger du? Forskellen er, at en sætning er en instruktion, der udfører et bestemt sæt af operationer, men et udtryk er et stykke kode, der udfører en eller anden beregning og returnerer et resultat.

Med andre ord, nu kan du gemme resultatet af et skift til en variabel.

Nok snak. Lad os nu se, hvordan den nye switch ser ud:

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

Det første, der fanger dit øje, er, hvor kompakt koden er. Kode, der plejede at optage det meste af skærmen, strækker sig nu over et par linjer og ser meget mere læsbar ud.

-> operatør

Du skal også bemærke -> operatoren (pileoperatoren). Du er måske allerede bekendt med det, hvis du har erfaring med lambda-udtryk.

Det betyder, at du nu kan skrive en cool switch i stil med et lambda statement. Piloperatoren angiver, at compileren ikke vil fortsætte til det næste kasusudtryk (hvis den aktuelle kasusblok mangler en break- eller return- sætning), men vil i stedet give dig værdien af ​​udtrykket til højre for pilen.

Du kan også skrive kode, der ikke er et udtryk og blot udføre visse handlinger i stedet for at returnere noget:

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

Bemærk, at switch ikke længere har en pauseerklæring . Det blev fjernet i Java 13 og erstattet med yield .

Hvad er udbytte og hvor kan det bruges?

Når en switch består af en enkelt linje, returnerer -> operatoren selv værdien. Men hvad hvis vi ikke har én, men mange linjer kode? I sådanne tilfælde returnerer pileoperatoren ikke en værdi, da der er flere linjer, ikke én.

Måske kan vi bruge retur ? Det bruges jo til at returnere værdier i Java. Ak, nej, retur vil ikke fungere med en switch. Så hvad kan vi bruge? Der plejede at være break , men det blev fjernet i Java 13. Men i stedet har vi nu yield - et nyt nøgleord, der hjælper dig med at returnere en værdi fra en switch. Det er analogt med at returnere udsagn i metoder.

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

Denne kode indeholder en enkelt linje, og -> operatoren vil returnere "hilsen".

Men når vi har en kodeblok:

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

Nøgleordet, der vil hjælpe dig med at returnere en værdi, er udbytte :

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

	}
};

yield blev tilføjet i Java 13 for tilfælde, hvor vi har mere end én linje kode i en sagsblok, og vi skal returnere et resultat.

Du er sikkert ivrig efter at prøve den nye switch i din kode, men husk at du skal bruge Java 14 eller nyere for at gøre dette. Med tidligere versioner vil denne switch kun være tilgængelig, hvis du angiver flaget "--enable-preview" på kommandolinjen, da det før version 14 var en del af den tekniske forhåndsvisning, ikke en fuldgyldig del af sproget.

Det er alt for nu! Vi ses!