Funzioni come valori
Funzioni di prima classe
Funzioni come valori è 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.
Le funzioni sono valori
In Scala, le funzioni sono valori di prima classe. È possibile memorizzarle in variabili, passarle come argomenti e restituirle da altre funzioni, proprio come numeri o stringhe.
object Main {
def main(args: Array[String]): Unit = {
val increment: Int => Int = x => x + 1
println(increment(5))
}
}Sintassi del tipo di funzione
Il tipo Int => String indica una funzione che accetta un Int e restituisce una String. Per più parametri si usano le parentesi: (Int, Int) => Int.
object Main {
def main(args: Array[String]): Unit = {
val add: (Int, Int) => Int = (a, b) => a + b
val label: Int => String = n => s"value=$n"
println(add(3, 4))
println(label(7))
}
}Sintassi delle lambda (funzioni anonime)
Una funzione anonima, o lambda, si scrive (params) => body. Non ha un nome e spesso viene passata direttamente a un'altra funzione.
object Main {
def main(args: Array[String]): Unit = {
val square = (x: Int) => x * x
println(square(6))
}
}Funzioni di ordine superiore
Una funzione di ordine superiore è una funzione che accetta una funzione come parametro oppure restituisce una funzione. map e filter sono esempi classici.
object Main {
def applyTwice(f: Int => Int, x: Int): Int = f(f(x))
def main(args: Array[String]): Unit = {
println(applyTwice(_ + 3, 10))
}
}Passare funzioni ai metodi
I metodi delle collezioni accettano funzioni. È possibile passare una lambda inline oppure un valore di funzione con nome.
object Main {
def main(args: Array[String]): Unit = {
val triple = (x: Int) => x * 3
println(List(1, 2, 3).map(triple))
println(List(1, 2, 3).map(x => x * 3))
}
}Restituire funzioni
Una funzione può restituire un'altra funzione. Qui multiplier restituisce una funzione che moltiplica per un fattore fisso, formando una piccola factory di funzioni.
object Main {
def multiplier(factor: Int): Int => Int = x => x * factor
def main(args: Array[String]): Unit = {
val timesTen = multiplier(10)
println(timesTen(5))
}
}Metodi e funzioni
Un def definisce un metodo. È possibile trasformare un metodo in un valore di funzione con l'underscore dell'eta-expansion: methodName _, oppure semplicemente usandolo dove è attesa una funzione.
object Main {
def doubleIt(x: Int): Int = x * 2
def main(args: Array[String]): Unit = {
val f: Int => Int = doubleIt
println(f(8))
println(List(1, 2, 3).map(doubleIt))
}
}Funzioni senza parametri
Una funzione può non accettare argomenti. Il suo tipo si scrive () => T. È utile per rimandare l'esecuzione del calcolo.
object Main {
def main(args: Array[String]): Unit = {
val greeting: () => String = () => "Hello!"
println(greeting())
}
}Memorizzare funzioni nelle collezioni
Poiché le funzioni sono valori, è possibile memorizzarle in liste o mappe e cercarle dinamicamente, creando un piccolo dispatcher di comandi.
object Main {
def main(args: Array[String]): Unit = {
val ops: Map[String, (Int, Int) => Int] = Map(
"add" -> (_ + _),
"mul" -> (_ * _)
)
println(ops("add")(3, 4))
println(ops("mul")(3, 4))
}
}Le funzioni come configurazione
Passare una funzione consente ai chiamanti di personalizzare il comportamento. Qui un transformAll generico applica una funzione a tutti gli elementi di una lista.
object Main {
def transformAll(xs: List[Int], f: Int => Int): List[Int] = xs.map(f)
def main(args: Array[String]): Unit = {
println(transformAll(List(1, 2, 3), _ + 100))
println(transformAll(List(1, 2, 3), _ * 10))
}
}Un esempio di personalizzazione più chiaro
Ecco la stessa idea espressa in modo più chiaro: i chiamanti forniscono la trasformazione, mantenendo l'helper generico e riutilizzabile.
object Main {
def transformAll(xs: List[Int], f: Int => Int): List[Int] = xs.map(f)
def main(args: Array[String]): Unit = {
println(transformAll(List(1, 2, 3), x => x + 100))
println(transformAll(List(1, 2, 3), x => x * x))
}
}Verifica rapida
Che cos'è una funzione di ordine superiore?
Riepilogo
Ha appreso che le funzioni sono valori di prima classe:
- Memorizzare funzioni in
val, liste e mappe - Tipi di funzione come
Int => String - Lambda:
(x) => bodye la forma abbreviata con_ - Le funzioni di ordine superiore accettano o restituiscono funzioni
- I metodi diventano valori di funzione tramite eta-expansion
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
Domande Frequenti
La lezione «Funzioni come valori» è gratuita?
Sì — il testo completo di «Funzioni come valori» è 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 «Funzioni come valori»?
Funzioni di prima classe 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 «Funzioni come valori»?
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
- Funzioni come valori
- Currying
- Composizione
- Closure