dichiarazione di commutazione | cambiare espressione

Quando scrivi codice con molte condizioni, sicuramente hai usato un'istruzione if-else o switch . Ma questa alternativa all'if -else presenta degli svantaggi. Alcune persone hanno persino definito l' istruzione switch un "anti-pattern".

Ma c'è una buona notizia: le nuove versioni di Java hanno portato molti cambiamenti nella sintassi del linguaggio, e uno di questi cambiamenti riguarda switch . Incuriosito? Allora andiamo a tuffarci.

Per cominciare, vale la pena chiarire perché lo switch è un anti-pattern. Considera il seguente codice:

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

Ok, quindi non è ancora del tutto chiaro perché questo sia un "anti-modello".

Ma cosa succede se aggiungiamo più blocchi case e ora il codice è simile a questo:

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

Aggiungiamo qualche riga in più: il codice si allunga. Successivamente possiamo aggiungere sempre più righe e nessuno ci impedirà di farlo.

Questo è il nocciolo del problema: dopo aver inizialmente creato un'istruzione switch compatta, vi aggiungiamo sempre più codice, occupando sempre più spazio - più di quanto possa stare sullo schermo - e rendendo il codice scomodo da leggere e mantenere.

Differenza tra l'istruzione switch e l'espressione switch

Java 14 ha introdotto uno switch nuovo e migliorato. Non è un'istruzione switch , ma piuttosto un'espressione switch .

Qual è la differenza, chiedi? La differenza è che un'istruzione è un'istruzione che esegue un determinato insieme di operazioni, mentre un'espressione è un pezzo di codice che esegue un calcolo e restituisce un risultato.

In altre parole, ora puoi salvare il risultato di un passaggio a una variabile.

Basta parlare. Ora vediamo come appare il nuovo interruttore :

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 prima cosa che salta all'occhio è la compattezza del codice. Il codice che occupava la maggior parte dello schermo ora si estende su poche righe e sembra molto più leggibile.

-> operatore

Dovresti anche notare l' operatore -> (operatore freccia). Potresti già conoscerlo se hai esperienza con le espressioni lambda.

Ciò significa che ora puoi scrivere un interruttore dall'aspetto accattivante nello stile di un'istruzione lambda. L'operatore freccia indica che il compilatore non procederà all'espressione case successiva (se il blocco case corrente non contiene un'istruzione break o return ), ma fornirà invece il valore dell'espressione a destra della freccia.

Puoi anche scrivere codice che non è un'espressione ed esegue semplicemente determinate azioni invece di restituire qualcosa:

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

Si noti che switch non ha più un'istruzione break . È stato rimosso in Java 13 e sostituito con yield .

Cos'è la resa e dove può essere utilizzata?

Quando uno switch è costituito da una singola riga, l' operatore -> stesso restituisce il valore. Ma cosa succede se non abbiamo una, ma molte righe di codice? In questi casi, l'operatore arrow non restituirà un valore, poiché ci sono più righe, non una.

Forse possiamo usare return ? Dopotutto, viene utilizzato per restituire valori in Java. Purtroppo no, il ritorno non funzionerà con un interruttore. Quindi cosa possiamo usare? C'era break , ma è stato rimosso in Java 13. Ma al suo posto ora abbiamo yield , una nuova parola chiave che ti aiuta a restituire un valore da uno switch. È analogo restituire le istruzioni nei metodi.

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

Questo codice contiene una singola riga e l' operatore -> restituirà "saluto".

Ma quando abbiamo un blocco di codice:

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

La parola chiave che ti aiuterà a restituire un valore è yield :

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

	}
};

yield è stato aggiunto in Java 13 per i casi in cui abbiamo più di una riga di codice in un case block e dobbiamo restituire un risultato.

Probabilmente sei ansioso di provare la nuova opzione nel tuo codice, ma ricorda che per farlo hai bisogno di Java 14 o versioni successive. Con le versioni precedenti, questa opzione sarà disponibile solo se specifichi il flag "--enable-preview" sulla riga di comando, poiché prima della versione 14 faceva parte dell'anteprima tecnica, non una parte completa del linguaggio.

È tutto per ora! Ci vediamo!