Scala for Backend Engineering & Functional Programming · Lezione

Guardie e binding

Condizioni nelle corrispondenze

Guardie e binding è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 3 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'è una guardia?

Una guardia aggiunge una condizione booleana a un caso usando if. Il caso corrisponde solo quando il pattern è compatibile e la guardia è vera.

Le guardie consentono di suddividere un singolo pattern in casi più specifici in base al valore.

Aggiungere una guardia if

Scriva la guardia dopo il pattern: case n if n > 0 =>. Se la condizione è falsa, il confronto continua con il caso successivo.

object Main {
  def sign(n: Int): String = n match {
    case x if x > 0 => "positive"
    case x if x < 0 => "negative"
    case _          => "zero"
  }
  def main(args: Array[String]): Unit = {
    println(sign(5))
    println(sign(-3))
    println(sign(0))
  }
}

Associare e poi applicare una guardia

La guardia può fare riferimento al nome associato nel pattern. In questo modo è possibile verificare le proprietà del valore confrontato.

object Main {
  def fizz(n: Int): String = n match {
    case x if x % 15 == 0 => "FizzBuzz"
    case x if x % 3 == 0  => "Fizz"
    case x if x % 5 == 0  => "Buzz"
    case x                => x.toString
  }
  def main(args: Array[String]): Unit = {
    println(fizz(15))
    println(fizz(9))
    println(fizz(7))
  }
}

Guardie sugli intervalli

Le guardie sono perfette per gli intervalli, che i pattern letterali non possono esprimere direttamente.

object Main {
  def band(score: Int): String = score match {
    case s if s >= 90 => "A"
    case s if s >= 80 => "B"
    case s if s >= 70 => "C"
    case _            => "F"
  }
  def main(args: Array[String]): Unit = {
    println(band(95))
    println(band(83))
    println(band(60))
  }
}

Associare un pattern con @

Il simbolo @ associa l'intero valore confrontato a un nome, continuando al tempo stesso a confrontarne la struttura.

Qui whole @ pattern significa: confronta pattern e chiama anche whole il valore corrispondente.

object Main {
  def main(args: Array[String]): Unit = {
    val x: Any = 7
    val msg = x match {
      case n @ (_: Int) => s"int value is $n"
      case _            => "other"
    }
    println(msg)
  }
}

Associazioni nelle collezioni

L'associazione con @ è particolarmente utile con i pattern strutturati, ad esempio per acquisire un'intera lista esaminandone contemporaneamente la testa.

object Main {
  def describe(xs: List[Int]): String = xs match {
    case all @ (first :: _) => s"starts with $first, full = $all"
    case Nil                => "empty"
  }
  def main(args: Array[String]): Unit = {
    println(describe(List(1, 2, 3)))
    println(describe(Nil))
  }
}

Combinare pattern di tipo e guardia

È possibile combinare un pattern di tipo con una guardia. Prima viene verificato il tipo, poi la condizione booleana.

object Main {
  def label(x: Any): String = x match {
    case s: String if s.length > 3 => "long string"
    case s: String                 => "short string"
    case _                         => "not a string"
  }
  def main(args: Array[String]): Unit = {
    println(label("hello"))
    println(label("hi"))
    println(label(42))
  }
}

Condizioni multiple

Una guardia è semplicemente un'espressione booleana, quindi è possibile combinare le condizioni con && e ||.

object Main {
  def category(age: Int): String = age match {
    case a if a >= 13 && a <= 19 => "teen"
    case a if a < 13             => "child"
    case _                       => "adult"
  }
  def main(args: Array[String]): Unit = {
    println(category(15))
    println(category(8))
    println(category(40))
  }
}

Le guardie non comportano fall-through

Se un pattern corrisponde ma la relativa guardia è falsa, Scala passa al caso successivo, non alla guardia successiva dello stesso pattern.

Si assicuri che un caso successivo possa gestire i valori che non superano nessuna guardia.

object Main {
  def test(n: Int): String = n match {
    case x if x > 100 => "big"
    case x            => s"not big: $x"
  }
  def main(args: Array[String]): Unit = {
    println(test(200))
    println(test(5))
  }
}

Perché usare guardie e associazioni?

Insieme, le guardie e le associazioni con @ rendono espressivo il pattern matching:

le guardie aggiungono condizioni come intervalli e divisibilità
@ acquisisce l'intero valore mentre lo destruttura
mantengono la logica di diramazione compatta e leggibile

Mettere tutto insieme

Questo esempio associa il valore, verifica una guardia e fornisce un'alternativa.

object Main {
  def temp(c: Int): String = c match {
    case t if t >= 30 => s"hot ($t)"
    case t if t >= 15 => s"mild ($t)"
    case t            => s"cold ($t)"
  }
  def main(args: Array[String]): Unit = {
    println(temp(35))
    println(temp(20))
    println(temp(5))
  }
}

Verifica rapida

Verifichi la Sua comprensione delle guardie e delle associazioni.

Riepilogo

Ha imparato a perfezionare i confronti:

una guardia è una condizione if dopo un pattern
se la guardia è falsa, il confronto passa al caso successivo
l'operatore @ associa l'intero valore mentre lo destruttura
le guardie si combinano con pattern di tipo e operatori booleani

Domande Frequenti

La lezione «Guardie e binding» è gratuita?

Sì — il testo completo di «Guardie e binding» è 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 «Guardie e binding»?

Condizioni nelle corrispondenze 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 3 di 4.

Quanto tempo richiede la lezione «Guardie e binding»?

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