Grondslag van functies en methodes in Scala

Handleidingen
Scala

Interesse in meer te leren over Scala? Neem de DataCamp-cursus Introduction to Scala.

Scala is een functionele programmeertaal die zowel functies als eerste-klassige waarden bevat alsook methoden en zowel overeenkomsten als verschillen heeft. Zowel functies als methoden zijn een blok herbruikbare code dat ook gebruikt wordt om herhaalde code op één plaats te bewaren, waardoor een functieoproep uitgevoerd wordt voor een specifieke taak. Ze maken code ook gemakkelijker te debuggen en te wijzigen.

However, functions are an object which is initialized in a variable, but methods start with the ‘def’ keyword followed by the method name, parameter list, method body with the return value.

Method Declaration and Definition

De syntaxis voor het declareren en definiëren van methoden in Scala is als volgt:

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

De methode in Scala begint met de volgende onderdelen:

  1. ‘def’: het keyword dat gebruikt wordt om methoden te declareren.
  2. ‘method_name’: de naam van uw methode, geschreven in lower camel case.
  3. ‘parameters’: de methodeparameters, die geen parameter of slechts één parameter hebben kunnen, maar gescheiden worden door een komma als er meer dan één parameter zijn.
  4. ‘return_type_of_parameters’: moet overeenkomen met het datatype van de ‘parameters_list’ en is verplicht.
  5. ‘return_type_of_method’: is optioneel, maar als standaard wordt ‘Unit’ teruggegeven, maar de waarde kan ook worden geretourneerd met de sleutelwoord ‘return’.
  6. Toewijzingsteken(‘=’): is optioneel, en als het wordt gebruikt zal de terugkeerwaarde worden toegewezen; als het niet wordt gebruikt zal de methode niets teruggeven.
  7. ‘method_body’: is het blok code dat tussen curly braces ‘{}’ is afgebeeld en bestaat uit de vereiste logica of bepaalde taak of bewerkingen.
  8. return: is het sleutelwoord dat wordt gebruikt om de vereiste waarden terug te geven en het programma te beëindigen, maar wordt zelden gebruikt in Scala.

Method Call

Het syntaxis voor een method call in Scala is onderstaand:

    method_name(arguments)

Een method call kan snel worden uitgevoerd door ‘method_name’, die de naam is van de corresponderende methode die u wilt aanroepen met de argumenten die worden doorgegeven.

Een methode met genoemde argumenten

Een methode met genoemde argumenten laat toe argumenten aan de parameters van de methode te geven tijdens de methode aanroep, waarbij elk argument wordt afgestemd op de methode parameters één voor één. U zult de voorbeelden hieronder zien van het geven van argumenten met een functie declaratie en definitie, samen met de method call 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));
   }
}

Het bovenstaande programma geeft de volgende uitvoer:
Difference of the value is: 2
Difference of the value is: 2

Het bovenstaande programma bevat een object ‘calculateResult’, waarin een methode genaamd ‘funSub’ zit met beide parameters x en y die een returntype hebben van ‘Int’. Het algeheel returntype van de methode is ‘Int’. Daarna volgt een toewijzingszin om de returnwaarde toe te kennen. De accolades geven het begin van de methodenlichaam aan, waar de variabele ‘diff’ geïnitialiseerd wordt met de beginwaarde 0. De methodeoproep ‘funSub(8,6)’ die in de hoofdmethode wordt uitgevoerd, koppelt 8 aan ‘x’ en 6 aan ‘y’, waarbij de aftrekking wordt uitgevoerd en de waarde van ‘diff’ wordt teruggegeven en uiteindelijk afgedrukt. Op dezelfde manier koppelt ‘funSub(x=8,y=6)’ 6 aan ‘y’ en 8 aan ‘x’ aan de parameters in de methode tijdens de oproep, waarbij de volgorde niet belangrijk is, en waar een soortgelijke bewerking wordt uitgevoerd en teruggegeven en het resultaat wordt afgedrukt.

Standaard Parameterwaarden

Je kunt standaardwaarden voor de methodeparameters opgeven door de initialisatie van de overeenkomstige waarden en de methodeoproep leeg te laten door geen argumenten door te geven.

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

   }
}

Het bovenstaande programma geeft de uitvoer als:
De laatste waarde is: 3

U kunt zien dat het bovenstaande programma een object bevat genaamd ‘calculateResult’ en binnen dat object een methode genaamd ‘funSub’ met de parameters x en y, die beide een return type ‘Int’ hebben, en dat de overall return type van de methode ‘Int’ is. Deze wordt gevolgd door een toewijzingstatement dat de terugkeerwaarde zal toewijzen. De curly braces duiden aan het begin van het lichaam van de methode, waar de variabele ‘diff’ wordt geïnitialiseerd met een beginwaarde van 0. Het methodecall wordt vanuit de main-methode uitgevoerd waar ‘funSub()’ wordt aangeroepen en de x wordt geïnitialiseerd tot 9 en de y tot 6, en de bewerking wordt uitgevoerd, waardoor de waarde ‘diff’ wordt teruggegeven en geprint.

Variabelenlang argumenten

Variabelenlang argumenten zijn argumenten die een willekeurig aantal argumenten kunnen hebben en door de gebruiker of klant kunnen worden doorgegeven. Het laatste parameter in de methode wordt aangegeven door middel van ‘*’, dat moet worden herhaald.

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

Het bovenstaande programma geeft de uitvoer als volgt:
Scala
is
great

U kunt zien dat het bovenstaande programma een object ‘variableArgument’ bevat met een ‘printAll’-methode waar een variabelenlang argument ‘String*’ aan het einde is gedefinieerd, en tijdens het aanroepen van de methode kan een lijst van strings worden doorgegeven. De doorgegeven lijst van strings wordt doorlopen en als uitvoer binnen de primaire functie getoond.

Recursieve functie

Recursie is de techniek die in functionele programmeertalen wordt gebruikt om problemen op te lossen door ze steeds opnieuw in kleinere subproblemen te delen, die aan het originele probleem zijn verwant. Met de oplossing van de kleinere problemen worden deze oplossingen toegepast om de oplossingen voor het originele probleem te krijgen. Daarom wordt het een divide-and-conquer of decrease-and-conquer probleem genoemd, wat de code netjes en elegant maakt. Bij het schrijven van een recursieve functie moeten twee punten strikt worden overwogen. Het zijn:

  • Basisgeval: Er kan meer dan één basisgeval zijn in een functie die anders kan leiden tot oneindige recursie. Het moet een oplossing hebben, d.w.z. de eenvoudige vorm van uitvoer of oplossing die kan worden behaald zonder recursie.
  • Recursief geval: Het geval waarin de recursieve functie wordt toegepast, d.w.z. recursieve aanroepen worden gemaakt. Het hoofd van het probleem is dat in elke recursieve aanroep, de grootte moet worden verminderd, d.w.z. het probleem moet worden verdeeld in kleinere subproblemen tot je het basisgeval bereikt. Uiteindelijk combineert u de oplossingen om de hoofdproblematiek te krijgen, wat een divide-conquer aanpak wordt genoemd.

Het factorial van elke gegeven getal is n! Het kan mathematisch worden uitgedrukt als volgt:

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

Het kan ook zijn dat de termen (n-1).(n-2)…3.2.1 worden aangenomen als (n-1)! Dus is het factorial van elke gegeven getal altijd n. (n-1)!

Nu kunt u zien hoe het probleem recursief wordt opgelost.

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

De bovenstaande code geeft de volgende uitvoer:
Faculteit van 1: = 1
Faculteit van 2: = 2
Faculteit van 3: = 6
Faculteit van 4: = 24
Faculteit van 5: = 120

U kunt bovenaan zien waar er een object genaamd ‘factorialDemo’ is en daarin is er een ‘main’-functie die een lus bevat die vijf keer herhaald wordt en ook een functieoproep naar ‘factorial’ bevat waarbij de recursieve functie een recursieve oproep doet, dat wil zeggen n tot vijf keer. Het stopt bij het basisgeval wanneer n minder dan of gelijk is aan 1, en het resultaat wordt teruggegeven en afgedrukt.

Anonieme Functie

Een anonieme functie is een lichtgewicht definitie van een functie zonder naam en wordt in Scala bekend als functieliteraal.

De syntax met voorbeeld van Anonieme Functies is als volgt:

  • De eerste syntax en een voorbeeld van een anonieme functie zijn:

Syntax:

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

Voorbeeld:

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

OF

  • De tweede syntax en een voorbeeld van een anonieme functie zijn:

Syntax:

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

Voorbeeld:

 (_:String)+(_:String)

De eerste syntax laat zien dat de expressie na “=>” tot een bepaalde waarde leidt terwijl een lijst van variabelen voor “=>” gebruikt wordt om de expressie te evalueren.

De tweede syntax hierboven werkt als een plaatsvervanger die de waarde als een ‘jokerteken’ maar één keer accepteert, waarna de operator tussen hen wordt uitgevoerd.

Je zult hieronder een voorbeeld van een anonieme functie zien:

 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}

                                   ^

Het bovenstaande programma geeft het volgende resultaat:
10
10

Je kunt zien dat hierboven het object genaamd ‘anonymousDemo’ met de ‘main’-functie twee anonieme functies bevat. Ze zijn syntactisch verschillend maar kunnen hetzelfde resultaat opleveren, waarbij ‘function’1 wordt uitgevoerd door de parameters van een functie-aanroep op te slaan tijdens het aanroepen—waarbij de waarden 5 en 5 worden doorgegeven, wat resulteert in de uitvoer die als 10 wordt afgedrukt terwijl ‘function2’ ook wordt aangeroepen door 7 en 3 door te geven waarbij het de waarde eenmaal ontvangt, die elke geldige ‘Integer’ accepteert. In jouw geval, voer de optelling uit en geef het resultaat terug.

Conclusie

Gefeliciteerd, je hebt dit handleiding gelezen.

Er zijn veel geavanceerde onderwerpen in Scala zoals hoger-orde functies, geneste functies, curry-functies, etc.

Referentie:
TOUR VAN SCALA BASICS
Scala | Functies – Basics
Scala – Functies
Anonieme Functies in Scala

Check out DataCamp’s Introduction to Scala cursus.

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