Scala for Backend Engineering & Functional Programming · Lezione

Indentazione significativa

Graffe facoltative

Lezione 1 di 413 passaggi

Indentazione significativa è 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.

Parentesi graffe opzionali

Scala 3 introduce l'indentazione significativa, detta anche sintassi con parentesi graffe opzionali. Invece di racchiudere i blocchi tra { }, è possibile delimitarli usando l'indentazione.

Le parentesi graffe continuano a funzionare e sono pienamente valide.
Il codice basato sull'indentazione è più pulito e simile a quello di Python.

object Main:
  def main(args: Array[String]): Unit =
    println("No braces needed")

Corpi dei metodi indentati

Il corpo di un metodo che segue = può essere un blocco indentato. Ogni istruzione allo stesso livello di indentazione appartiene a quel corpo.

La ultima espressione è il valore restituito.

object Main:
  def square(x: Int): Int =
    val result = x * x
    result

  def main(args: Array[String]): Unit =
    println(square(5))

Espressioni if indentate

Le strutture di controllo usano la nuova sintassi senza parentesi graffe. Dopo if cond then si indenta il ramo, mentre else è allineato con if.

then è obbligatorio nello stile senza parentesi graffe.
Non sono necessarie parentesi attorno alla condizione.

object Main:
  def main(args: Array[String]): Unit =
    val n = 7
    val label =
      if n % 2 == 0 then "even"
      else "odd"
    println(label)

Cicli for indentati

Il ciclo for usa do per gli effetti collaterali o yield per costruire collezioni; in entrambi i casi si usa l'indentazione.

object Main:
  def main(args: Array[String]): Unit =
    for i <- 1 to 3 do
      println(s"line $i")

    val doubled =
      for i <- 1 to 3 yield i * 2
    println(doubled)

Cicli while indentati

Il ciclo while usa do seguito da un blocco indentato nello stile con parentesi graffe opzionali.

object Main:
  def main(args: Array[String]): Unit =
    var i = 0
    while i < 3 do
      println(s"i = $i")
      i += 1

Espressioni match indentate

Il pattern matching si presta naturalmente all'indentazione. Le clausole case sono indentate sotto match.

object Main:
  def describe(n: Int): String =
    n match
      case 0 => "zero"
      case 1 => "one"
      case _ => "many"

  def main(args: Array[String]): Unit =
    println(describe(1))
    println(describe(9))

Corpi di classi e trait

Anche classi, trait e oggetti possono omettere le parentesi graffe. I due punti : dopo l'intestazione aprono il corpo indentato.

class Point(x: Int, y: Int):
  def show: String = s"($x, $y)"

object Main:
  def main(args: Array[String]): Unit =
    println(Point(2, 3).show)

Il marcatore end

Per i blocchi indentati lunghi è possibile aggiungere un marcatore end per chiarire dove termina una definizione. Questo migliora la leggibilità di metodi o classi di grandi dimensioni.

Forma: end <name> oppure end if, end while e così via.
È facoltativo e viene verificato dal compilatore.

object Main:
  def greet(name: String): String =
    val msg = s"Hello, $name"
    msg
  end greet

  def main(args: Array[String]): Unit =
    println(greet("Ada"))
  end main
end Main

Combinare parentesi graffe e indentazione

È possibile combinare liberamente entrambi gli stili. Alcuni team mantengono le parentesi graffe per maggiore chiarezza nei casi annidati. Le regole di indentazione vengono applicate solo dove le parentesi graffe sono assenti.

object Main:
  def main(args: Array[String]): Unit = {
    val xs = List(1, 2, 3)
    val total =
      xs.foldLeft(0)((acc, x) => acc + x)
    println(total)
  }

Problemi comuni con l'indentazione

L'indentazione è significativa, quindi deve essere coerente.

Usi gli spazi, senza mescolarli alle tabulazioni.
Una riga non allineata può finire silenziosamente fuori da un blocco.
I due punti : sono necessari per i corpi dei template (classi/oggetti), ma non per i corpi dei metodi dopo =.

object Main:
  def main(args: Array[String]): Unit =
    val items = List("a", "b")
    items.foreach: item =>
      println(item.toUpperCase)

Sintassi degli argomenti con meno parentesi graffe

Scala 3 consente anche di passare un blocco come argomento dopo i due punti. items.foreach: x => apre il corpo indentato di una lambda, evitando parentesi tonde e graffe annidate.

object Main:
  def main(args: Array[String]): Unit =
    val nums = List(1, 2, 3, 4)
    val evens = nums.filter: n =>
      n % 2 == 0
    println(evens)

Verifica rapida

Verifichi la sua comprensione dell'indentazione significativa.

Rispondi nella lezione interattiva

Riepilogo

Ha imparato a usare l'indentazione significativa di Scala 3.

I blocchi possono usare l'indentazione invece di { }.
Le strutture di controllo usano then, do e yield.
I corpi di classi, oggetti e trait iniziano con i due punti :.
I marcatori end chiariscono i blocchi lunghi.
I due stili possono essere combinati; mantenga coerente la spaziatura.

object Main:
  def main(args: Array[String]): Unit =
    for i <- 1 to 2 do
      if i == 1 then println("first")
      else println("second")
  end main
end Main

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 «Indentazione significativa» è gratuita?

Sì — il testo completo di «Indentazione significativa» è 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 «Indentazione significativa»?

Graffe facoltative 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 «Indentazione significativa»?

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