Byt uttryck kontra switch-sats

När du skriver kod med många villkor har du säkert använt antingen en if-else eller en switch- sats. Men detta alternativ till om-annat har nackdelar. Vissa människor har till och med kallat switch- satsen för ett "antimönster".

Men det finns goda nyheter: nya versioner av Java har medfört många förändringar i språkets syntax, och en av dessa ändringar påverkar switch . Fascinerad? Låt oss sedan dyka in.

Till att börja med är det värt att klargöra varför switch är ett antimönster. Tänk på följande kod:

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

Okej, så det är ännu inte helt klart varför detta är ett "antimönster".

Men vad händer om vi lägger till fler fallblock och nu ser koden ut så här:

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

Låt oss lägga till några rader till — koden blir längre. Senare kan vi lägga till fler och fler rader, och ingen kommer att hindra oss från att göra detta.

Det här är problemets kärna: efter att först ha skapat en kompakt switch -sats lägger vi till mer och mer kod till den, tar upp mer och mer plats – mer än vad som får plats på skärmen – och gör koden obekväm att läsa och underhålla.

Skillnaden mellan switch-satsen och switch-uttrycket

Java 14 introducerade en ny och förbättrad switch. Det är inte ett switch-uttryck , utan snarare ett switch-uttryck .

Vad är skillnaden, frågar du? Skillnaden är att en sats är en instruktion som utför en viss uppsättning operationer, men ett uttryck är en kodbit som utför någon beräkning och returnerar ett resultat.

Med andra ord, nu kan du spara resultatet av en växling till en variabel.

Nog pratat. Låt oss nu se hur den nya switchen ser ut:

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örsta som fångar ditt öga är hur kompakt koden är. Koden som brukade ta upp större delen av skärmen sträcker sig nu över några rader och ser mycket mer läsbar ut.

-> operatör

Du bör också notera operatorn -> (piloperator). Du kanske redan är bekant med det om du har erfarenhet av lambda-uttryck.

Det betyder att du nu kan skriva en cool switch i stil med ett lambda-statement. Piloperatorn indikerar att kompilatorn inte kommer att gå vidare till nästa case- uttryck (om det aktuella case- blocket saknar en break- eller return -sats), utan istället ger dig värdet på uttrycket till höger om pilen.

Du kan också skriva kod som inte är ett uttryck och helt enkelt utföra vissa åtgärder istället för att returnera något:

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

Observera att switch inte längre har ett break -meddelande. Den togs bort i Java 13 och ersattes med yield .

Vad är avkastning och var kan det användas?

När en switch består av en enda rad, returnerar operatorn -> själv värdet. Men vad händer om vi inte har en, utan många rader kod? I sådana fall returnerar inte piloperatorn ett värde, eftersom det finns flera rader, inte en.

Kanske kan vi använda retur ? Det används trots allt för att returnera värden i Java. Tyvärr, nej, retur fungerar inte med en switch. Så vad kan vi använda? Det brukade finnas break , men det togs bort i Java 13. Men i stället har vi nu yield — ett nytt nyckelord som hjälper dig att returnera ett värde från en switch. Det är analogt att returnera uttalanden i metoder.

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

Denna kod innehåller en enda rad och operatorn -> kommer att returnera "hälsning".

Men när vi har ett kodblock:

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

Nyckelordet som hjälper dig att returnera ett värde är avkastning :

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

	}
};

yield lades till i Java 13 för fall där vi har mer än en kodrad i ett caseblock och vi behöver returnera ett resultat.

Du är förmodligen sugen på att testa den nya switchen i din kod, men kom ihåg att du behöver Java 14 eller högre för att göra detta. Med tidigare versioner kommer denna växel endast att vara tillgänglig om du anger flaggan "--enable-preview" på kommandoraden, eftersom den före version 14 var en del av den tekniska förhandsgranskningen, inte en fullfjädrad del av språket.

Det var allt tills vidare! Vi ses!