0Pricing
Scala for Backend Engineering & Functional Programming · Lezione

Sintassi e tipi di base

Comprenda la sintassi fondamentale di Scala, le dichiarazioni di variabili (val/var), i tipi di dati comuni e gli operatori di base.

Sintassi e tipi di base è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 2 di 3. 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 3 lezioni in totale.

La sintassi pulita di Scala

Benvenuti nella sintassi di base di Scala! Scala è progettato per essere conciso ed espressivo e spesso consente di ottenere di più scrivendo meno codice.

A differenza di alcuni linguaggi, i punti e virgola sono generalmente facoltativi alla fine di una riga se contiene una sola istruzione. Questo aiuta a mantenere pulito il codice.

Le espressioni sono fondamentali

In Scala, quasi tutto è un'espressione, cioè produce un valore. È un concetto potente, che rende il codice più funzionale e prevedibile.

Anche un semplice calcolo o un blocco condizionale può restituire un valore.

Provi a eseguire questo esempio:

object Main {
  def main(args: Array[String]): Unit = {
    val x = 5 + 3
    println(s"The value of x is: $x")

    val message = if (x > 7) "Greater than 7" else "Not greater than 7"
    println(message)
  }
}

`val`: valori immutabili

Quando dichiara una variabile usando val, crea un valore immutabile. Ciò significa che, una volta assegnato, il suo valore non può essere modificato.

L'immutabilità è un principio fondamentale della programmazione funzionale e aiuta a prevenire effetti collaterali imprevisti, rendendo il codice più sicuro e facile da comprendere.

Provi:

object Main {
  def main(args: Array[String]): Unit = {
    val greeting = "Hello, Coddy!"
    println(greeting)
    // greeting = "New message" // This would cause a compile error!
  }
}

`var`: variabili mutabili

A volte è necessaria una variabile il cui valore possa cambiare. A questo scopo, Scala mette a disposizione var per le variabili mutabili.

Sebbene sia utile, in Scala è buona norma preferire val a var quando possibile, per adottare l'immutabilità e lo stile funzionale.

Vediamo come funziona `var`:

object Main {
  def main(args: Array[String]): Unit = {
    var counter = 0
    println(s"Initial counter: $counter")
    counter = counter + 1
    println(s"New counter: $counter")
  }
}

Numeri: Int, Long, Double

Scala supporta i tipi numerici comuni. Il compilatore spesso deduce il tipo, ma è possibile specificarlo.

  • Int: per i numeri interi (ad esempio 10)
  • Long: per i numeri interi più grandi (suffisso L, ad esempio 10000000000L)
  • Double: per i numeri in virgola mobile (decimali, ad esempio 3.14)

Ecco un esempio:

object Main {
  def main(args: Array[String]): Unit = {
    val anInt = 42
    val aLong = 1234567890123L
    val aDouble = 3.14159

    println(s"Int: $anInt")
    println(s"Long: $aLong")
    println(s"Double: $aDouble")
  }
}

Tipi Boolean e Char

Oltre ai numeri, Scala dispone di tipi per i valori booleani e i singoli caratteri:

  • Boolean: rappresenta i valori booleani, ovvero true o false.
  • Char: memorizza un singolo carattere, racchiuso tra apici singoli (ad esempio 'A').

Questi tipi sono fondamentali per la logica e l'elaborazione del testo.

Esempio:

object Main {
  def main(args: Array[String]): Unit = {
    val isActive = true
    val initial = 'C'

    println(s"Is active? $isActive")
    println(s"Initial character: $initial")
  }
}

Stringhe e testo

Il tipo String viene utilizzato per sequenze di caratteri, ovvero testo. In Scala, le stringhe sono immutabili, proprio come in Java.

Una funzionalità molto utile è la String Interpolation, che consente di incorporare espressioni direttamente nei valori letterali stringa usando il prefisso s e $ per le variabili.

Osservi:

object Main {
  def main(args: Array[String]): Unit = {
    val name = "Coddy"
    val age = 3

    val greeting = s"Hello, my name is $name and I am $age years old."
    println(greeting)

    val mathResult = s"Two plus two is ${2 + 2}"
    println(mathResult)
  }
}

Operatori aritmetici di base

Scala fornisce operatori aritmetici standard per eseguire calcoli con i numeri:

  • + (addizione)
  • - (sottrazione)
  • * (moltiplicazione)
  • / (divisione)
  • % (modulo - resto della divisione)

Questi operatori funzionano come previsto e restituiscono un nuovo valore numerico.

Facciamo qualche calcolo:

object Main {
  def main(args: Array[String]): Unit = {
    val a = 10
    val b = 3

    println(s"Addition: ${a + b}")
    println(s"Subtraction: ${a - b}")
    println(s"Multiplication: ${a * b}")
    println(s"Division: ${a / b} (integer division)")
    println(s"Modulo: ${a % b}")

    val c = 10.0
    val d = 3.0
    println(s"Float Division: ${c / d}")
  }
}

Operatori di confronto

Gli operatori di confronto servono per confrontare due valori e restituiscono sempre un Boolean (true o false).

  • == (uguale a)
  • != (diverso da)
  • < (minore di)
  • > (maggiore di)
  • <= (minore o uguale a)
  • >= (maggiore o uguale a)

Sono essenziali per il flusso di controllo e il processo decisionale.

object Main {
  def main(args: Array[String]): Unit = {
    val x = 10
    val y = 5

    println(s"x == y: ${x == y}")
    println(s"x != y: ${x != y}")
    println(s"x > y: ${x > y}")
    println(s"x <= y: ${x <= y}")
  }
}

Verifica rapida: variabili e operatori

Consideri il seguente frammento di codice Scala:

object Main {
  def main(args: Array[String]): Unit = {
    val num1 = 7
    var num2 = 3
    num2 = num1 * 2
    val finalResult = num1 + num2 - 5
    println(finalResult)
  }
}

Riepilogo: sintassi e tipi

Ottimo lavoro! In questa lezione ha appreso i fondamenti della sintassi di base di Scala, tra cui l'uso delle espressioni e la natura facoltativa dei punti e virgola.

Ha esplorato come dichiarare variabili usando val per i valori immutabili e var per quelli mutabili. Ha inoltre acquisito familiarità con tipi di dati comuni come Int, Long, Double, Boolean, Char e String, inclusa la pratica String Interpolation.

Infine, si è esercitato nell'uso degli operatori aritmetici e di confronto di base per eseguire calcoli e verifiche logiche. Continui a esercitarsi con questi concetti fondamentali: sono i mattoni su cui si basano programmi Scala più complessi!

Domande Frequenti

La lezione «Sintassi e tipi di base» è gratuita?

Sì — il testo completo di «Sintassi e tipi di base» è 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 3 lezioni in totale.

Cosa imparerò in «Sintassi e tipi di base»?

Comprenda la sintassi fondamentale di Scala, le dichiarazioni di variabili (val/var), i tipi di dati comuni e gli operatori di base. 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 3.

Quanto tempo richiede la lezione «Sintassi e tipi di base»?

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

  1. Primi passi con Scala
  2. Sintassi e tipi di base
  3. Strutture di controllo e funzioni
← Torna a Scala for Backend Engineering & Functional Programming