De basis van functies en methoden in Scala

Wil je meer leren over Scala? Volg de cursus Introduction to Scala van DataCamp.

Scala is een functionele programmeertaal met zowel functies als eersteklas waarden als methoden, met overeenkomsten en verschillen. Zowel functies als methoden zijn blokken herbruikbare code om terugkerende code op één plek op te slaan, waarna een functieaanroep een specifieke taak uitvoert. Ze maken code ook makkelijker te debuggen en aan te passen.

Functies zijn objecten die aan een variabele worden toegekend, terwijl methoden beginnen met het sleutelwoord 'def' gevolgd door de methode­naam, parameterlijst, methodetekst en de geretourneerde waarde.

Methode­declaratie en -definitie

De syntaxis voor een methodedeclaratie en -definitie in Scala is als volgt:

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

Een methode in Scala bestaat uit de volgende onderdelen:

1. 'def': sleutelwoord dat wordt gebruikt om methoden te declareren.
2. 'method_name': de naam van je methode, in lower camel case.
3. 'parameters': de methodeparameters; er kan geen, één of meerdere parameters zijn, bij meer dan één gescheiden door een komma.
4. 'return_type_of_parameters': moet overeenkomen met het gegevenstype van 'parameters_list' en is verplicht.
5. 'return_type_of_method': is optioneel; standaard wordt 'Unit' geretourneerd, maar je kunt een waarde teruggeven met het sleutelwoord 'return'.
6. Toekenningssymbool ('='): is optioneel; als het wordt gebruikt, wordt de geretourneerde waarde toegewezen; laat je het weg, dan retourneert de methode niets.
7. 'method_body': het codeblok tussen accolades '{}' met de benodigde logica of uit te voeren taken/bewerkingen.
8. return: sleutelwoord om waarden terug te geven en het programma te beëindigen, maar in Scala zelden gebruikt.

Methodeaanroep

De syntaxis voor een methodeaanroep in Scala is als volgt:

    method_name(arguments)

Je roept snel een methode aan met 'method_name', de naam van de betreffende methode die je wilt aanroepen, waaraan je de argumenten doorgeeft.

Een methode met benoemde argumenten

Met benoemde argumenten kun je tijdens de methodeaanroep waarden doorgeven aan de parameters van de methode, waarbij elk argument één op één wordt gekoppeld aan een parameter. Hieronder zie je een voorbeeld van het doorgeven van argumenten met een functiedeclaratie en -definitie, plus de methodeaanroep in actie:

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));
   }
}

Bovenstaand programma geeft de volgende output:
Difference of the value is: 2
Difference of the value is: 2

Het programma bevat een object 'calculateResult' en daarin een methode 'funSub' met de parameters x en y, beide van het type 'Int'; het algehele returntype van de methode is ook 'Int'. Er volgt een toekenningsinstructie om de geretourneerde waarde toe te wijzen. De accolades markeren het begin van de methodetekst, waar de variabele 'diff' wordt geïnitialiseerd met 0. De methodeaanroep 'funSub(8,6)' in de main-methode koppelt 8 aan 'x' en 6 aan 'y', voert de aftrekking uit, retourneert de waarde van 'diff' en print die. Op dezelfde manier koppelt 'funSub(x=8,y=6)' 6 aan 'y' en 8 aan 'x' tijdens de methodeaanroep; de volgorde maakt dus niet uit. De bewerking is hetzelfde, de waarde wordt geretourneerd en het resultaat geprint.

Standaardwaarden voor parameters

Je kunt standaardwaarden opgeven voor methodeparameters door ze te initialiseren. Je kunt de methode dan ook aanroepen zonder argumenten te passeren.

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() );

   }
}

Bovenstaand programma geeft de volgende output:
The final value is: 3

Zoals je ziet bevat het programma een object 'calculateResult' met daarin de methode 'funSub' met parameters x en y, beide van het type 'Int'; het algehele returntype van de methode is 'Int' en er volgt een toekenningsinstructie om de returnwaarde toe te wijzen. De accolades markeren het begin van de methodetekst, waar de variabele 'diff' wordt geïnitialiseerd met 0. De methodeaanroep gebeurt in de main-methode: 'funSub()' initialiseert x op 9 en y op 6, voert de bewerking uit en retourneert en print de waarde van 'diff'.

Argumenten met variabele lengte

Argumenten met variabele lengte zijn argumenten waarbij een variabel aantal waarden kan worden doorgegeven door de gebruiker of client. De laatste parameter in de methode wordt gedeclareerd met '*' en kan herhaald worden.

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;
      }
    }
}

Bovenstaand programma geeft de volgende output:
Scala
is
great

Je ziet dat het programma een object 'variableArgument' bevat met de methode 'printAll', waarbij aan het eind het argument met variabele lengte 'String*' is gedefinieerd. Bij het aanroepen van de methode kan zo een lijst met strings worden doorgegeven. De doorgegeven lijst wordt doorlopen en in de main-functie als output getoond.

Recursieve functie

Recursie is een techniek in functioneel programmeren waarbij een probleem wordt opgelost door het herhaaldelijk op te splitsen in kleinere deelproblemen die lijken op het oorspronkelijke probleem. De kleinere problemen worden opgelost en hun oplossingen worden gecombineerd om de oplossing voor het oorspronkelijke probleem te verkrijgen. Dit heet een divide-and-conquer- of decrease-and-conquer-aanpak en levert vaak schone, elegante code op. Bij het schrijven van een recursieve functie moet je twee punten strikt in acht nemen:

• Basisgeval: Er kunnen meerdere basisgevallen in een functie zijn; die moet je bepalen, anders kan er oneindige recursie ontstaan. Er moet een oplossing zijn, dus een eenvoudige vorm van uitkomst die zonder recursie haalbaar is.
• Recursief geval: Het geval waarin de recursieve functie wordt toegepast, d.w.z. waarin recursieve aanroepen plaatsvinden. De kern is dat bij elke recursieve aanroep de probleemgrootte afneemt, d.w.z. je verdeelt het probleem in kleinere subproblemen totdat je het basisgeval bereikt. Tot slot combineer je de oplossingen om het hoofdprobleem op te lossen: de divide-and-conquer-aanpak.

De faculteit van een getal is n! en kan wiskundig als volgt worden uitgedrukt:

Je kunt (n-1).(n-2)...3.2.1 ook schrijven als (n-1)!. Dus de faculteit van een getal is altijd n.(n-1)!

Hieronder zie je de recursieve manier om het probleem op te lossen.

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)
   }
}

Bovenstaand programma geeft de volgende output:
Factorial of 1: = 1
Factorial of 2: = 2
Factorial of 3: = 6
Factorial of 4: = 24
Factorial of 5: = 120

Zoals je ziet is er een object 'factorialDemo' met daarin een 'main'-functie die een lus bevat die vijf keer herhaalt en een aanroep van de functie 'factorial'. De recursieve functie doet recursieve aanroepen, d.w.z. van n naar vijf. Hij stopt bij het basisgeval zodra n kleiner dan of gelijk aan 1 is; daarna wordt het resultaat geretourneerd en geprint.

Anonieme functie

Anonieme functies zijn lichte functiedefinities zonder naam en staan in Scala bekend als function literal.

Syntaxis met voorbeeld voor anonieme functies:

• De eerste syntaxis en een voorbeeld voor een anonieme functie is:

Syntaxis:

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

Voorbeeld:

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

OF

• De tweede syntaxis en een voorbeeld voor een anonieme functie is:

Syntaxis:

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

Voorbeeld:

 (_:String)+(_:String)

De eerste syntaxis laat zien dat de expressie na "=>" evalueert naar een bepaalde waarde, terwijl de lijst met variabelen vóór "=>" wordt gebruikt om de expressie te evalueren.

De tweede syntaxis werkt als een placeholder: hij accepteert de waarde als een 'wildcard' slechts één keer, waarna de operator erop wordt toegepast.

Hieronder zie je een voorbeeld van een anonieme functie:

 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}

                                   ^

Bovenstaand programma geeft de volgende output:
10
10

Je ziet het object 'anonymousDemo' met de 'main'-functie die twee anonieme functies bevat. Ze zijn syntactisch verschillend maar leveren hetzelfde resultaat op: 'function1' evalueert door parameters te nemen uit de functieaanroep waarin hij wordt aangeroepen—hier worden de waarden 5 en 5 doorgegeven, wat als output 10 geeft—terwijl 'function2' wordt aangeroepen met 7 en 3; hij ontvangt de waarden één keer en accepteert elke geldige 'Integer'. In dit geval wordt de optelling uitgevoerd en het resultaat geprint.

Conclusie

Gefeliciteerd, je hebt deze tutorial uitgelezen.

Er zijn veel geavanceerde onderwerpen in Scala, zoals higher-order functions, geneste functies, currying, enzovoort.

Referentie:
TOUR OF SCALA BASICS
Scala | Functions – Basics
Scala - Functions
Anonymous Functions in Scala

Bekijk ook de cursus Introduction to Scala van DataCamp.