Scala for Backend Engineering & Functional Programming · Lezione

Filtrare con if

Guardie nelle comprehension

Filtrare con if è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 2 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.

Guard nelle for-comprehension

All'interno di una for-comprehension è possibile aggiungere una condizione if chiamata guard. Mantiene solo gli elementi che soddisfano la condizione, proprio come filter.

object Main {
  def main(args: Array[String]): Unit = {
    val evens = for (x <- 1 to 10 if x % 2 == 0) yield x
    println(evens)
  }
}

I guard diventano withFilter

Un guard if cond viene riscritto in una chiamata a withFilter (una variante lazy di filter).

for (x <- xs if p(x)) yield x
diventa xs.withFilter(p).map(x => x)

object Main {
  def main(args: Array[String]): Unit = {
    val sugar = for (x <- List(1, 2, 3, 4) if x > 2) yield x
    val desugared = List(1, 2, 3, 4).withFilter(_ > 2).map(x => x)
    println(sugar == desugared)
  }
}

Perché withFilter invece di filter

withFilter è lazy: non crea una collezione intermedia. La condizione viene applicata solo quando viene eseguito il successivo map o flatMap, risparmiando memoria e lavoro.

object Main {
  def main(args: Array[String]): Unit = {
    val nums = List(1, 2, 3, 4, 5, 6)
    val result = for (n <- nums if n % 3 == 0) yield n * 100
    println(result)
  }
}

Più guard

È possibile concatenare diversi guard. Si combinano come un AND logico: un elemento deve soddisfare tutte le condizioni per essere mantenuto.

object Main {
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- 1 to 20
      if x % 2 == 0
      if x % 3 == 0
    } yield x
    println(result)
  }
}

Guard con più generatori

I guard possono comparire dopo qualsiasi generatore e filtrano quel livello di iterazione. Posizioni il guard subito dopo il generatore i cui valori deve verificare.

object Main {
  def main(args: Array[String]): Unit = {
    val coprimeSums = for {
      x <- 1 to 3
      y <- 1 to 3
      if x != y
    } yield (x, y)
    println(coprimeSums)
  }
}

Combinare un guard e un'associazione di valore

È possibile combinare liberamente i guard (if) con le associazioni di valori (=). L'ordine è importante: un'associazione definita prima di un guard può essere usata all'interno di quel guard.

object Main {
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- 1 to 6
      square = x * x
      if square > 10
    } yield square
    println(result)
  }
}

Guard nelle collezioni String

I guard funzionano con qualsiasi predicato, non solo con quelli numerici. Qui filtriamo le parole in base alla lunghezza.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("scala", "go", "java", "rust", "c")
    val longWords = for (w <- words if w.length >= 4) yield w.toUpperCase
    println(longWords)
  }
}

Filtrare gli Option

Per un Option, un guard non soddisfatto trasforma il risultato in None. Questo rende le for-comprehension un modo chiaro per convalidare valori opzionali.

object Main {
  def main(args: Array[String]): Unit = {
    val ok  = for (x <- Some(8) if x > 5) yield x
    val bad = for (x <- Some(3) if x > 5) yield x
    println(ok)
    println(bad)
  }
}

La posizione del guard ne cambia il significato

Una guardia vede solo i valori associati sopra di essa. Se la si inserisce prima del generatore di cui ha bisogno, il codice non verrà compilato. Posizioni sempre la guardia dopo il generatore pertinente.

object Main {
  def main(args: Array[String]): Unit = {
    val result = for {
      x <- 1 to 3
      y <- 1 to 3
      if x + y == 4
    } yield s"$x + $y = ${x + y}"
    result.foreach(println)
  }
}

Guardie e filtro finale

Potrebbe filtrare il risultato dopo la comprehension, ma una guardia filtra durante l'iterazione. Con più generatori, le guardie possono eliminare presto i rami non validi, riducendo il lavoro complessivo.

object Main {
  def main(args: Array[String]): Unit = {
    val withGuard = for {
      x <- 1 to 100
      if x % 25 == 0
    } yield x
    println(withGuard)
  }
}

Pipeline di validazione leggibili

Impostare più guardie in sequenza fa leggere il codice come una checklist di condizioni. Questo è uno degli usi più idiomatici delle for-comprehension nel codice Scala reale.

object Main {
  def main(args: Array[String]): Unit = {
    val valid = for {
      n <- List(4, 7, 12, 15, 20)
      if n > 5
      if n < 18
      if n % 2 == 0
    } yield n
    println(valid)
  }
}

Verifica rapida

In quale metodo viene desugared una guardia (if) in una for-comprehension?

Riepilogo

Ha imparato a usare le guardie nelle for-comprehension:

if cond filtra gli elementi durante l'iterazione
Le guardie vengono desugared in withFilter (filtraggio lazy)
Più guardie si combinano come un AND logico
Una guardia vede solo i valori associati sopra di essa
Le guardie si combinano liberamente con generatori e associazioni con =

Domande Frequenti

La lezione «Filtrare con if» è gratuita?

Sì — il testo completo di «Filtrare con if» è 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 «Filtrare con if»?

Guardie nelle comprehension 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 2 di 4.

Quanto tempo richiede la lezione «Filtrare con if»?

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