Basic di funzioni e metodi in Scala

Tutorial
Scala

Se sei interessato a conoscere di più su Scala, prendi il corso di Introduzione a Scala su DataCamp.

Scala è un linguaggio di programmazione funzionale che include sia funzioni come valori di primo livello che metodi. Possiede sia somiglianze che differenze con entrambi. Entrambe le funzioni e i metodi sono blocchi di codice riutilizzabili utilizzati per memorizzare il codice ripetuto in un solo posto, che consente di richiamare una funzione per svolgere una particolare task specifica. Anche questi rendono il codice più facile da debugare e modificare.

Tuttavia, le funzioni sono un oggetto inizializzato in una variabile, mentre i metodi iniziano con il keyword ‘def’ seguito dal nome del metodo, dalla lista dei parametri e dal corpo del metodo con il valore di ritorno.

Dichiarazione e definizione del metodo

La sintassi per la dichiarazione e la definizione del metodo in Scala è la seguente:

def 'method_name' ('parameters':'return_type_parameters') : ('return_type_of_method') = {
    'method_body'
     return 'value'
}

Il metodo in Scala comincia con le seguenti parti:

  1. ‘def’: keyword utilizzato per dichiarare metodi.
  2. ‘method_name’: è il nome del tuo metodo, che è in lower camel case.
  3. ‘parameters’: sono i parametri del metodo che possono avere zero o un solo parametro ma sono separati da una virgola quando ci sono più di un parametro.
  4. ‘return_type_of_parameters’: deve corrispondere secondo il tipo di dato degli ‘parameters_list’ ed è obbligatorio.
  5. ‘return_type_of_method’: è opzionale, ma di default viene restituito ‘Unit’, ma il valore può essere restituito usando la parola chiave ‘return’.
  6. Simbolo di assegnazione(‘=’): è opzionale, e se usato assegnerà il valore di ritorno; se non viene usato, il metodo non restituirà nulla.
  7. ‘method_body’: è il blocco di codice racchiuso tra parentesi graffe ‘{}’ e consiste nella logica richiesta o in una certa operazione o compiti.
  8. return: è la parola chiave usata per restituire i valori richiesti e anche per terminare il programma, ma raramente viene usata in Scala.

Chiamata di Metodo

La sintassi per la chiamata di metodo in Scala è la seguente:

    method_name(arguments)

La chiamata di metodo può essere effettuata rapidamente tramite ‘method_name’, che è il nome del metodo corrispondente che si desidera chiamare, con gli argomenti passati.

Metodo con Argomenti Nomevoli

Il metodo con argomenti nomevoli consente di passare l’argomento ai parametri del metodo durante la chiamata del metodo, in cui ogni argomento è abbinato uno ad uno ai parametri del metodo. Vedrai l’esempio seguente di passaggio degli argomenti con la dichiarazione e definizione della funzione insieme 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 come output:
La differenza del valore è: 2
La differenza del valore è: 2

Il programma riportato sopra contiene un oggetto ‘calculateResult’, che include un metodo chiamato ‘funSub’ con entrambi i parametri x e y che hanno un tipo di ritorno ‘Int’, il tipo di ritorno complessivo del metodo è ‘Int’. Viene seguito da un’istruzione di assegnazione per assegnare il valore di ritorno. Le parentesi graffe indicano l’inizio del corpo del metodo, dove la variabile ‘diff’ è inizializzata con il valore iniziale di 0. Il chiamata di metodo ‘funSub(8,6)’ fatta nella classe principale corrisponde a 8 a ‘x’ e a 6 a ‘y’, e viene eseguita l’operazione di sottrazione, il valore di ‘diff’ è restituito e infine stampato. Allo stesso modo, ‘funSub(x=8,y=6)’ corrisponde a 6 a ‘y’ e a 8 a ‘x’ ai parametri del metodo durante la chiamata di metodo in cui l’ordine non importa, viene eseguita una operazione simile e il valore di ritorno viene stampato.

Valori predefiniti per i Parametri

Puoi specificare i valori predefiniti per i parametri del metodo tramite l’inizializzazione dei valori corrispondenti e lasciando la chiamata del metodo vuota senza passare l’argomento.

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 fornisce l’output come:
Il valore finale è: 3

Il programma sopra contiene un oggetto definito come ‘calculateResult’ e all’interno c’è un metodo chiamato ‘funSub’ con i parametri x e y, entrambi con tipo di ritorno ‘Int’. Il tipo di ritorno complessivo del metodo è ‘Int’ ed è seguito da una dichiarazione di assegnazione che assegnerà il valore di ritorno. Le parentesi graffe indicano l’inizio del corpo del metodo, dove la variabile ‘diff’ è inizializzata con il valore iniziale di 0. Il metodo viene chiamato all’interno dal metodo principale dove ‘funSub()’ chiama e inizializza x a 9 e y a 6, e l’operazione viene eseguita, il che fa sì che il valore ‘diff’ sia restituito e stampato.

Argomenti a lunghezza variabile

Gli argomenti a lunghezza variabile sono argomenti che accettano qualsiasi numero variabile di argomenti e possono essere passati dall’utente o dal cliente. L’ultimo parametro nel metodo è dichiarato usando ‘*’ che deve essere ripetuto.

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 come output:
Scala
è
grande

Si può vedere che il programma sopra contiene un oggetto ‘variableArgument’ con i metodi ‘printAll’ in cui è definito l’argomento a lunghezza variabile ‘String*’ alla fine e durante la chiamata del metodo può essere passata una lista di stringhe. La lista di stringhe passata viene sfruttata in un ciclo e mostrata come output all’interno della funzione primaria.

Funzione ricorsiva

La ricorsione è una tecnica usata nella programmazione funzionale dove il problema viene risolto ripetutamente sbarrandolo in sottomisure più piccole, simili all’originale. Più sottomisure minori vengono risolte e le loro soluzioni sono applicate per ottenere la soluzione del problema originale. Quindi, è chiamata strategia di dividere e conquistare o di diminuire e conquistare, che rende il codice pulito e elegante. Quando si scrive una funzione ricorsiva, ci sono due punti da considerare strettamente. Sono:

  • Caso base: Ci potrebbero essere più di un caso base in una funzione che deve essere scoperto altrimenti potrebbe condurre a una ricorsione infinita. Deve avere una soluzione, cioè la semplice forma di output o soluzione che può essere raggiunto senza ricorsione.
  • Caso ricorsivo: Il caso in cui la funzione ricorsiva è applicata, cioè le chiamate ricorsive vengono fatte. La sostanza principale del problema è che in ogni chiamata ricorsiva, la dimensione deve diminuire, cioè il problema deve essere diviso in sottomisure più piccole finché non si raggiunge il caso base. Alla fine, si combinano le soluzioni per ottenere il problema principale, che è chiamata strategia di dividere e conquistare.

Il fattoriale di qualsiasi numero dato è n! È possibile espresselo matematicamente come segue:

n! = n.(n-1).(n-2)…3.2.1

Anche se puoi considerare i termini (n-1).(n-2)…3.2.1 come (n-1)! Quindi, il fattoriale di qualsiasi numero dato è sempre n. (n-1)!

Ora puoi vedere qui sotto la risoluzione del problema ricorsiva.

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 di cui sopra produce l’output come:
Fattoriale di 1: = 1
Fattoriale di 2: = 2
Fattoriale di 3: = 6
Fattoriale di 4: = 24
Fattoriale di 5: = 120

Come puoi vedere sopra, c’è un oggetto chiamato ‘factorialDemo’ e all’interno di esso, c’è una funzione ‘main’ che contiene un ciclo che si ripete cinque volte e include anche una chiamata di funzione a ‘factorial’ in cui la funzione ricorsiva effettua una chiamata ricorsiva, cioè n cinque volte. Si ferma al caso base quando n diventa minore o uguale a 1, e il risultato viene restituito e stampato.

Funzione Anonima

La Funzione Anonima è una definizione di funzione leggera che non ha un nome e viene chiamata funzione letterale in Scala.

La sintassi con esempio per la Funzione Anonima sono le seguenti:

  • La prima sintassi e un esempio per la funzione anonima sono:

Sintassi:

('first_variable':'data_type', 'second_variable':'data_type') => "certain_expression"

Esempio:

(var1:String:var2:String) => var1 + var2

OPPURE

  • La seconda sintassi e un esempio per la Funzione Anonima sono:

Sintassi:

 (_:'data_type')operator(_'data_type')

Esempio:

 (_:String)+(_:String)

La prima sintassi mostra che l’espressione dopo “=>” viene valutata in un valore particolare mentre una lista di variabili prima di “=>” viene usata per valutare l’espressione.

La seconda sintassi funziona come un segnaposto che accetta il valore come carattere ‘jolly’ una sola volta, e poi l’operatore viene operato tra di loro.

Vedrete qui sotto 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 restituisce l’output come:
10
10

Potete vedere sopra l’oggetto chiamato ‘anonymousDemo’ con la funzione ‘main’ che contiene due funzioni anonime. Sono diverse sintatticamente ma possono produrre lo stesso risultato, dove ‘function’1 viene valutato prendendo i parametri da una chiamata di funzione mentre viene chiamata – passando i valori 5 e 5, il quale produce come output da stampare 10 mentre ‘function2’ viene anche chiamata passando 7 e 3 dove riceve il valore una volta, che accetta qualsiasi valido ‘Integer’. Nel tuo caso, fai l’operazione di addizione e restitisci il risultato.

Conclusione

Congratulazioni, hai finito di leggere questo tutorial.

Esistono molti argomenti avanzati in Scala come le funzioni di ordine superiore, le funzioni annidate, le funzioni curry, ecc.

Riferimento:
TOUR DI BASI DI SCALA
Scala | Funzioni – Basi
Scala – Funzioni
Funzioni Anonime in Scala

Dai un’occhiata al corso di DataCamp Introduzione a Scala.

Source:
https://www.datacamp.com/tutorial/basic-functions-methods-scala