Scala for Backend Engineering & Functional Programming · Lezione

Espressioni match

Diramare in base alla struttura

Espressioni match è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Che cos'è match?

match è il potente costrutto di diramazione di Scala. Gli si fornisce un valore e una serie di pattern case, quindi viene eseguito il primo ramo corrispondente.

Lo si può considerare una versione basata sulle espressioni e più potente dell'istruzione switch.

Sintassi di base

Si scrive value match { case pattern => result }. Ogni case definisce un pattern e il codice da eseguire quando corrisponde.

Poiché match è un'espressione, l'intera struttura restituisce un valore.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 2
    val word = n match {
      case 1 => "one"
      case 2 => "two"
      case 3 => "three"
    }
    println(word)
  }
}

Il caso jolly

Il carattere di sottolineatura _ è un jolly che corrisponde a qualsiasi valore. Lo si usa come caso predefinito generale alla fine.

Senza di esso, un valore senza corrispondenza genera un MatchError durante l'esecuzione.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 9
    val word = n match {
      case 1 => "one"
      case 2 => "two"
      case _ => "many"
    }
    println(word)
  }
}

Corrispondenza di stringhe

I pattern non sono limitati ai numeri. È possibile confrontare direttamente i valori letterali di tipo stringa.

object Main {
  def main(args: Array[String]): Unit = {
    val cmd = "start"
    val msg = cmd match {
      case "start" => "Starting up"
      case "stop"  => "Shutting down"
      case _       => "Unknown command"
    }
    println(msg)
  }
}

match restituisce un valore

Poiché ogni ramo produce un valore, è possibile assegnare il risultato di match a un val o usarlo direttamente nel codice.

In questo modo il codice rimane ordinato e si evitano variabili mutabili.

object Main {
  def main(args: Array[String]): Unit = {
    val light = "red"
    println(s"Action: " + (light match {
      case "red"   => "stop"
      case "green" => "go"
      case _       => "caution"
    }))
  }
}

Combinare i casi

È possibile confrontare più valori in un unico caso usando | (la barra verticale). Tutti i valori elencati conducono allo stesso ramo.

object Main {
  def main(args: Array[String]): Unit = {
    val day = "Sat"
    val kind = day match {
      case "Sat" | "Sun" => "weekend"
      case _             => "weekday"
    }
    println(kind)
  }
}

match in una funzione

Un pattern comune consiste nel rendere l'intero corpo della funzione una singola espressione match. Il risultato del confronto diventa il valore restituito.

object Main {
  def describe(n: Int): String = n match {
    case 0 => "zero"
    case 1 => "one"
    case _ => "other"
  }
  def main(args: Array[String]): Unit = {
    println(describe(0))
    println(describe(5))
  }
}

Associare l'intero valore

È possibile associare il valore confrontato a un nome nel caso jolly usando case other =>. In questo modo è possibile usare other in quel ramo.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 42
    val result = n match {
      case 0     => "nothing"
      case other => s"got $other"
    }
    println(result)
  }
}

L'ordine è importante

I casi vengono verificati dall'alto verso il basso e vince la prima corrispondenza. Inserisca i pattern più specifici prima di quelli generali.

Un jolly inserito troppo presto nasconderebbe i casi sottostanti.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 1
    val msg = n match {
      case 1 => "specific one"
      case _ => "anything else"
    }
    println(msg)
  }
}

Perché usare match?

Il pattern matching è fondamentale in Scala perché:

rende chiara la diramazione su più casi
restituisce un valore come espressione
si adatta a tipi, strutture dati e guardie
può essere verificato dal compilatore per controllarne la completezza

Mettere tutto insieme

Ecco un piccolo classificatore che usa valori letterali, un caso combinato e un caso predefinito.

object Main {
  def grade(score: Int): String = score match {
    case 10 | 9 => "excellent"
    case 8 | 7  => "good"
    case _      => "keep trying"
  }
  def main(args: Array[String]): Unit = {
    println(grade(9))
    println(grade(7))
    println(grade(3))
  }
}

Verifica rapida

Verifichi la Sua comprensione delle espressioni match.

Riepilogo

Ha appreso le nozioni di base di match:

la sintassi è value match { case pattern => result }
_ è il jolly generale
i valori si combinano con |
match è un'espressione che restituisce un valore
i casi vengono provati dall'alto verso il basso; vince la prima corrispondenza

Domande Frequenti

La lezione «Espressioni match» è gratuita?

Sì — il testo completo di «Espressioni match» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Cosa imparerò in «Espressioni match»?

Diramare in base alla struttura Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?

Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Espressioni match»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?

Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Scala for Backend Engineering & Functional Programming