{count, plural, one {Corso} other {Corsi}}
Introduction to Scala
{hours} ore
27.1K
Ti interessa saperne di più su Scala? Segui il corso Introduzione a Scala di DataCamp.
Scala è un linguaggio di programmazione funzionale che include sia funzioni come valori di prima classe sia metodi; presenta quindi somiglianze e differenze tra i due concetti. Funzioni e metodi sono entrambi blocchi di codice riutilizzabile, utili per raccogliere in un unico punto il codice ripetuto e consentire chiamate che eseguono un compito specifico. Rendono inoltre il codice più facile da fare debug e da modificare.
Le funzioni sono oggetti che vengono assegnati a variabili, mentre i metodi iniziano con la parola chiave 'def' seguita dal nome, dalla lista dei parametri e dal corpo del metodo con il valore di ritorno.
Dichiarazione e definizione di un metodo
La sintassi per dichiarare e definire un metodo in Scala è la seguente:
def 'method_name' ('parameters':'return_type_parameters') : ('return_type_of_method') = {
'method_body'
return 'value'
}
Un metodo in Scala è composto dalle seguenti parti:
- 'def': parola chiave usata per dichiarare i metodi.
- 'method_name': il nome del metodo, in lower camel case.
- 'parameters': i parametri del metodo; può non avere parametri, averne uno solo o più di uno, in tal caso separati da virgole.
- 'return_type_of_parameters': deve corrispondere al tipo di dato della 'parameters_list' ed è obbligatorio.
- 'return_type_of_method': è opzionale; per impostazione predefinita viene restituito 'Unit', ma si può restituire un valore usando la parola chiave 'return'.
- Simbolo di assegnazione ('='): è opzionale; se usato, assegna il valore di ritorno, se omesso il metodo non restituirà nulla.
- 'method_body': è il blocco di codice racchiuso tra parentesi graffe '{}' e contiene la logica, il compito o le operazioni richieste.
- return: parola chiave usata per restituire i valori richiesti e terminare l'esecuzione, ma è raramente utilizzata in Scala.
Chiamata di un metodo
La sintassi per chiamare un metodo in Scala è la seguente:
method_name(arguments)
La chiamata si effettua tramite 'method_name', cioè il nome del metodo che vuoi invocare, passando gli argomenti richiesti.
Un metodo con argomenti con nome
I metodi con argomenti con nome permettono di passare i valori ai parametri del metodo durante la chiamata, associando ciascun argomento al parametro corrispondente per nome. Di seguito un esempio di passaggio degli argomenti con dichiarazione e definizione della funzione, oltre alla chiamata del metodo in azione:
object calculateResult {
def funSub(x:Int, y:Int) : Int =
{
var diff:Int = 0
diff = x - y
// return value
return diff
}
def main(args: Array[String]) {
// Function call
println("Difference of the value is: " + funSub(8,6));
println("Difference of the value is " + funSub(y=6,x=8));
}
}
Il programma sopra produce in output:
Difference of the value is: 2
Difference of the value is: 2
Il programma contiene un oggetto 'calculateResult', al cui interno c'è un metodo chiamato 'funSub' con entrambi i parametri x e y di tipo restituito 'Int'; anche il tipo restituito complessivo del metodo è 'Int'. È seguito da un'assegnazione per restituire il valore. Le parentesi graffe indicano l'inizio del corpo del metodo, dove la variabile 'diff' è inizializzata a 0. La chiamata 'funSub(8,6)' eseguita nel main associa 8 a 'x' e 6 a 'y', quindi effettua la sottrazione, restituisce il valore di 'diff' e lo stampa. Allo stesso modo, 'funSub(x=8,y=6)' associa 6 a 'y' e 8 a 'x' durante la chiamata, in cui l'ordine non conta: viene eseguita la stessa operazione e il risultato viene restituito e stampato.
Valori predefiniti dei parametri
Puoi specificare valori predefiniti per i parametri del metodo inizializzandoli con valori corrispondenti, e puoi lasciare vuota la chiamata al metodo senza passare argomenti.
object calculateResult {
def funSub(x:Int=9, y:Int=6) : Int =
{
var diff:Int = 0
diff = x - y
// return value
return diff
}
def main(args: Array[String]) {
// Function call
print( "The final value is: " + funSub() );
}
}
Il programma sopra produce in output:
The final value is: 3
Come vedi, l'oggetto definito è 'calculateResult' e contiene un metodo chiamato 'funSub' con parametri x e y, entrambi di tipo 'Int'; il tipo restituito complessivo del metodo è 'Int' ed è seguito da un'istruzione di assegnazione che assegna il valore di ritorno. Le parentesi graffe indicano l'inizio del corpo del metodo, dove la variabile 'diff' è inizializzata a 0. La chiamata è eseguita nel main: 'funSub()' inizializza x a 9 e y a 6, esegue l'operazione, restituisce 'diff' e lo stampa.
Argomenti a lunghezza variabile
Gli argomenti a lunghezza variabile sono parametri che accettano un numero qualsiasi di argomenti e possono essere passati dall'utente o dal client. L'ultimo parametro del metodo è dichiarato usando '*' per indicare la ripetizione.
object variableArgument {
def main(args: Array[String]) {
printAll("Scala", "is", "great")
}
def printAll(strings: String*) {
var i : Int = 0;
for( value <- strings ){
println(value);
i = i + 1;
}
}
}
Il programma sopra produce in output:
Scala
is
great
Come vedi, l'oggetto 'variableArgument' contiene il metodo 'printAll' in cui l'argomento a lunghezza variabile 'String*' è definito alla fine; durante la chiamata del metodo è possibile passare un elenco di stringhe. L'elenco passato viene iterato e stampato in output all'interno della funzione principale.
Funzione ricorsiva
La ricorsione è una tecnica usata nella programmazione funzionale in cui il problema viene risolto spezzandolo ripetutamente in sottoproblemi più piccoli, simili al problema originale. I problemi più piccoli vengono risolti e le loro soluzioni combinate per ottenere la soluzione del problema iniziale. Per questo è detta strategia divide et impera o decrease-and-conquer, che rende il codice pulito ed elegante. Scrivendo una funzione ricorsiva, occorre considerare rigorosamente due aspetti:
- Caso base: in una funzione può esserci più di un caso base; bisogna individuarli, altrimenti si rischia la ricorsione infinita. Deve avere una soluzione, ovvero una forma semplice di output ottenibile senza ricorsione.
- Caso ricorsivo: il caso in cui si applica la funzione ricorsiva, cioè si effettuano chiamate ricorsive. Il punto centrale è che a ogni chiamata la dimensione del problema deve diminuire, ossia va suddiviso in sottoproblemi sempre più piccoli finché non si raggiunge il caso base. Infine, si combinano le soluzioni per risolvere il problema principale, approccio tipico del divide et impera.
Il fattoriale di un numero n è n! e può essere espresso matematicamente così:
Si può anche osservare che i termini (n-1).(n-2)...3.2.1 sono pari a (n-1)!, quindi il fattoriale di un numero è sempre n.(n-1)!
Ecco di seguito la soluzione ricorsiva del problema.
object factorialDemo {
def main(args: Array[String]) {
for (i <- 1 to 5)
println( "Factorial of " + i + ": = " + factorial(i) )
}
def factorial(n: Int): Int = {
if (n <= 1)
return 1
else
return n * factorial(n - 1)
}
}
Il programma sopra produce in output:
Factorial of 1: = 1
Factorial of 2: = 2
Factorial of 3: = 6
Factorial of 4: = 24
Factorial of 5: = 120
Come vedi, c'è un oggetto chiamato 'factorialDemo' e al suo interno una funzione 'main' con un ciclo che si ripete cinque volte e include una chiamata alla funzione 'factorial', che richiama ricorsivamente sé stessa da n fino a cinque. Si ferma al caso base quando n è minore o uguale a 1; il risultato viene quindi restituito e stampato.
Funzione anonima
Le funzioni anonime sono definizioni di funzione leggere che non hanno un nome e in Scala sono dette letterali di funzione.
Sintassi con esempio per le funzioni anonime:
- Prima sintassi con esempio per una funzione anonima:
Sintassi:
('first_variable':'data_type', 'second_variable':'data_type') => "certain_expression"
Esempio:
(var1:String:var2:String) => var1 + var2
OPPURE
- Seconda sintassi con esempio per una funzione anonima:
Sintassi:
(_:'data_type')operator(_'data_type')
Esempio:
(_:String)+(_:String)
La prima sintassi mostra che l'espressione dopo "=>" viene valutata producendo un certo valore, mentre l'elenco delle variabili prima di "=>" serve per valutarla.
La seconda sintassi funziona come un segnaposto: accetta il valore come carattere jolly una sola volta, e quindi l'operatore viene applicato tra di essi.
Di seguito un esempio di funzione anonima:
object anonymousDemo
{
def main(args: Array[String])
{
var function1 = (var1:Int, var2:Int) => var1 + var2
var function2 = (_:Int) + (_:Int)
// function call
println(function1(5, 5))
println(function2(7, 3))
}
}
Initializing Scala interpreter ...
Spark Web UI available at http://DESKTOP-03TH7J0:4040
SparkContext available as 'sc' (version = 2.4.3, master = local[*], app id = local-1566986265958)
SparkSession available as 'spark'
<console>:10: error: unbound placeholder parameter
var function2 = {_:Int} + {_:Int}
^
<console>:10: error: unbound placeholder parameter
var function2 = {_:Int} + {_:Int}
^
Il programma sopra produce in output:
10
10
Come vedi, l'oggetto 'anonymousDemo' con la funzione 'main' contiene due funzioni anonime. Sono sintatticamente diverse ma producono lo stesso risultato: 'function1' valuta l'espressione prendendo i parametri dalla chiamata—passando i valori 5 e 5—e stampa 10; 'function2' viene chiamata passando 7 e 3, riceve i valori una volta, accetta qualsiasi 'Integer' valido, esegue l'addizione e stampa il risultato.
Conclusione
Congratulazioni, hai terminato la lettura di questo tutorial.
In Scala ci sono molti argomenti avanzati, come funzioni di ordine superiore, funzioni annidate, currying, ecc.
Riferimenti:
TOUR OF SCALA BASICS
Scala | Functions – Basics
Scala - Functions
Anonymous Functions in Scala
Dai un'occhiata al corso Introduzione a Scala di DataCamp.
Argomenti
