Scala for Backend Engineering & Functional Programming · Lezione

Espressioni invece di istruzioni

Tutto è un'espressione

Lezione 3 di 413 passaggi

Espressioni invece di istruzioni è 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.

Espressioni e istruzioni

Una istruzione esegue un'operazione, ma non restituisce nulla di utile. Un'espressione viene valutata producendo un valore.

In Scala quasi tutto è un'espressione. È un concetto fondamentale che influenza il modo in cui si scrive il codice.

if è un'espressione

In molti linguaggi if è un'istruzione. In Scala, if/else restituisce un valore, quindi può assegnarlo direttamente a un val.

Non è necessario usare una variabile separata assegnata in ogni ramo.

object Main {
  def main(args: Array[String]): Unit = {
    val temp = 30
    val label = if (temp > 25) "hot" else "mild"
    println(label)
  }
}

I blocchi sono espressioni

Anche un blocco { ... } è un'espressione. Il suo valore è quello della sua ultima riga.

Può quindi calcolare valori intermedi e concludere con il risultato.

object Main {
  def main(args: Array[String]): Unit = {
    val result = {
      val a = 2
      val b = 3
      a * b
    }
    println(result)
  }
}

match è un'espressione

Anche il pattern matching con match restituisce un valore. Ogni ramo produce un risultato e l'intera espressione restituisce il valore del ramo corrispondente.

object Main {
  def main(args: Array[String]): Unit = {
    val day = 3
    val name = day match {
      case 1 => "Mon"
      case 2 => "Tue"
      case 3 => "Wed"
      case _ => "Other"
    }
    println(name)
  }
}

Il tipo Unit

Alcune espressioni esistono solo per il loro effetto collaterale, come println. Restituiscono Unit, scritto ().

Unit è simile a void di altri linguaggi, ma è comunque un valore reale.

object Main {
  def main(args: Array[String]): Unit = {
    val nothing: Unit = println("side effect")
    println(nothing)
  }
}

Restituzione dalle funzioni

Poiché il corpo di una funzione è un'espressione, l'ultima espressione ne costituisce il valore restituito. Raramente è necessario usare la parola chiave return.

In questo caso il corpo della funzione è una singola espressione.

object Main {
  def max(a: Int, b: Int): Int = if (a > b) a else b
  def main(args: Array[String]): Unit = {
    println(max(7, 4))
  }
}

Funzioni orientate alle espressioni

Una funzione può essere un'espressione a blocco la cui ultima riga è il risultato. Questo mantiene compatta la logica ed evita variabili temporanee mutabili.

object Main {
  def discount(price: Double): Double = {
    val rate = if (price > 100) 0.2 else 0.1
    price * (1 - rate)
  }
  def main(args: Array[String]): Unit = {
    println(discount(150.0))
  }
}

Nessuna mutabilità necessaria

Poiché if e match sono espressioni, può assegnarne il risultato a un val invece di modificare un var.

In questo modo si ottiene un codice più pulito e funzionale.

object Main {
  def main(args: Array[String]): Unit = {
    val score = 85
    val grade = if (score >= 90) "A"
      else if (score >= 80) "B"
      else "C"
    println(grade)
  }
}

Composizione delle espressioni

Poiché tutto restituisce un valore, le espressioni possono annidarsi e combinarsi liberamente. L'output di una diventa l'input di un'altra.

Questa componibilità è uno dei motivi principali per cui Scala è un linguaggio così espressivo.

object Main {
  def main(args: Array[String]): Unit = {
    val n = 7
    val message = "n is " + (if (n % 2 == 0) "even" else "odd")
    println(message)
  }
}

Perché è importante

Il codice orientato alle espressioni:

Riduce la necessità di variabili mutabili
Rende esplicito il flusso dei valori
Si combina naturalmente in programmi più grandi
Si abbina perfettamente all'immutabilità

Tutti gli elementi insieme

Qui un'espressione a blocco contiene un'espressione if, il tutto assegnato a un unico risultato immutabile.

object Main {
  def main(args: Array[String]): Unit = {
    val total = {
      val items = 3
      val each = 12
      val raw = items * each
      if (raw > 30) raw - 5 else raw
    }
    println(total)
  }
}

Verifica rapida

Verifichi la propria comprensione delle espressioni.

Rispondi nella lezione interattiva

Riepilogo

Ha imparato che in Scala quasi tutto è un'espressione:

if/else, match e i blocchi restituiscono tutti dei valori
Il valore di un blocco è quello della sua ultima espressione
Le espressioni con effetti collaterali restituiscono Unit (())
L'ultima espressione di una funzione è il valore restituito
Questo riduce la mutabilità e migliora la componibilità

Gratis per iniziare

Impara Scala con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 39
Lezioni: 143

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Espressioni invece di istruzioni» è gratuita?

Sì — il testo completo di «Espressioni invece di istruzioni» è 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 invece di istruzioni»?

Tutto è un'espressione 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 «Espressioni invece di istruzioni»?

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