Grundlagen von Funktionen und Methoden in Scala

Tutorials
Scala

Interessiert an mehr über Scala zu lernen? Nehmen Sie an DataCamps Einführung in Scala-Kurs teil.

Scala ist eine funktionale Programmiersprache, die sowohl Funktionen als erste Klassenwerte als auch Methoden enthält und Ähnlichkeiten以及Unterschiede aufweist. Sowohl Funktionen als auch Methoden sind Blöcke wiederverwendbaren Codes, die auch verwendet werden, um wiederkehrenden Code an einer Stelle zu speichern, was eine Funktionsaufruf ermöglicht, um bestimmte spezifische Aufgaben auszuführen. Sie machen auch den Code einfacher debuggen und modifizieren.

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.

Methoden Deklaration und Definition

Die Syntax für die Methodendeklaration und Definition in Scala ist unten angegeben:

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

Die Methode in Scala beginnt mit den folgenden Teilen:

  1. ‚def‘: Schlüsselwort, das zur Deklaration von Methoden verwendet wird.
  2. ‚method_name‘: ist der Name Ihrer Methode, der in kleinem Kamelnotation geschrieben ist.
  3. ‚parameters‘: sind die Methodenparameter, die keinen Parameter haben können oder nur einen Parameter, aber durch ein Komma getrennt werden, wenn es mehr als einen Parameter gibt.
  4. ‚return_type_of_parameters‘: muss der Datentyp der ‚parameters_list‘ entsprechen und ist zwingend erforderlich.
  5. ‚return_type_of_method‘: Dieser Wert ist optional, aber standardmäßig wird ‚Unit‘ zurückgegeben. Der Wert kann jedoch mit dem Schlüsselwort ‚return‘ zurückgegeben werden.
  6. Zuweisungszeichen(‚=‘): Dies ist optional und wenn es verwendet wird, wird der Rückgabewert zugewiesen. Ohne es zu verwenden, wird die Methode nichts zurückgeben.
  7. ‚method_body‘: Dies ist der Codeblock, der von geschweiften Klammern ‚{}‘ eingeschlossen ist und die erforderliche Logik oder bestimmte Aufgaben oder Operationen enthält.
  8. return: Dies ist das Schlüsselwort, das verwendet wird, um den erforderlichen Wert zurückzugeben und das Programm zu beenden, wird jedoch kaum in Scala verwendet.

Methode aufrufen

Die Syntax für einen Methodenaufruf in Scala lautet wie folgt:

    method_name(arguments)

Der Methodenaufruf kann schnell durch ‚method_name‘ erfolgen, was der Name der entsprechenden Methode ist, die Sie mit den Argumenten aufrufen möchten.

Eine Methode mit benannten Argumenten

Die Methode mit benannten Argumenten erlaubt es, Argumente während des Methodenaufrufs den Methodenparametern zuzuweisen, wobei jedes Argument einzeln mit den Methodenparametern abgeglichen wird. Sie werden unten ein Beispiel sehen, wie die Argumente mit der Funktionsdeklaration und -definition zusammen mit dem Methodenaufruf verwendet werden:

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

Das obige Programm gibt folgenden Output aus:
Der Wert der Differenz ist: 2
Der Wert der Differenz ist: 2

Das obige Programm enthält ein Objekt ‚calculateResult‘, und darin ist eine Methode namens ‚funSub‘ enthalten, bei der beide Parameter x und y den Rückgabetyp ‚Int‘ haben. Der gesamte Rückgabetyp der Methode ist ‚Int‘. Es folgt eine Zuweisungsanweisung, um den Rückgabewert zuzuweisen. Die geschweiften Klammern kennzeichnen den Beginn des Methodenrumpfs, in dem die Variable ‚diff‘ mit dem Anfangswert 0 initialisiert wird. Der Methodenaufruf ‚funSub(8,6)‘, der in der Hauptmethode durchgeführt wird, ordnet 8 ‚x‘ und 6 ‚y‘ zu, und die Subtraktionsoperation wird durchgeführt, und der Wert von ‚diff‘ wird zurückgegeben und schließlich gedruckt. Ebenso ordnet ‚funSub(x=8,y=6)‘ 6 ‚y‘ und 8 ‚x‘ den Parametern in der Methode während des Methodenaufrufs zu, wobei die Reihenfolge keine Rolle spielt, wo eine ähnliche Operation durchgeführt wird und das Ergebnis zurückgegeben und ausgegeben wird.

Standardparameterwerte

Sie können die Standardwerte für die Methodenparameter durch die Initialisierung der entsprechenden Werte angeben und den Methodenaufruf leer lassen, indem Sie das Argument nicht übergeben.

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

   }
}

Das obige Programm gibt die Ausgabe:
Der endgültige Wert ist: 3

Das obige Programm enthält ein Objekt definiert als ‚calculateResult‘, in dem sich eine Methode namens ‚funSub‘ befindet, die die Parameter x und y hat, beide mit dem Rückgabetyp ‚Int‘. Der Rückgabetyp der Methode ist auch ‚Int‘. Es folgt eine Zuweisungsanweisung, die den Rückgabewert zuweist. Die geschweiften Klammern kennzeichnen den Beginn des Methodenrumpfs, wo die Variable ‚diff‘ mit dem Anfangswert 0 initialisiert wird. Der Methodenaufruf erfolgt innerhalb der main-Methode, wo ‚funSub()‘ aufgerufen wird und x auf 9 und y auf 6 initialisiert, woraufhin die Operation durchgeführt wird, wodurch der Wert ‚diff‘ zurückgegeben und ausgegeben wird.

Variable Länge von Argumenten

Variable Länge von Argumenten sind Argumente, die eine beliebige Anzahl von Argumenten enthalten können und vom Benutzer oder Kunden übergeben werden können. Der letzte Parameter in der Methode wird mit einem ‚*‘ deklariert, das wiederholt werden muss.

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

Das obige Programm gibt folgenden Output aus:
Scala
ist
großartig

Wie Sie sehen können, enthält das obige Programm ein Objekt ‚variableArgument‘ mit der Methode ‚printAll‘, wo am Ende ein Argument der variablen Länge ‚String*‘ definiert ist. Bei der Methodenaufruf kann eine Liste von Zeichenfolgen übergeben werden. Die übergebene Liste von Zeichenfolgen wird in der primären Funktion durchlaufen und als Output angezeigt.

Rekursive Funktion

Rekursion ist eine Technik in der funktionalen Programmierung, wo das Problem durch iterative Zerlegung in kleinere Unterprobleme gelöst wird, die dem ursprünglichen Problem ähneln. Je mehr diese Unterprobleme gelöst werden und deren Lösungen angewendet werden, um die Lösung des ursprünglichen Problems zu erhalten, desto klarer und eleganter wird der Code. Daher wird dies als divide-and-conquer oder decrease-and-conquer bezeichnet, was zu einer sauberen und eleganten Codestruktur führt. Beim Schreiben einer rekursiven Funktion müssen zwei Punkte strikt beachtet werden:

  • Basisfall: Es kann mehr als ein Basisfall in einer Funktion geben, die sonst zu unendlicher Rekursion führen könnte. Es muss eine Lösung haben, d.h. eine einfache Form des Ergebnisses oder der Lösung, die ohne Rekursion erreicht werden kann.
  • Rekursiver Fall: Der Fall, in dem die rekursive Funktion angewendet wird, d.h. rekursive Aufrufe getätigt werden. Der Hauptgrund des Problems ist, dass bei jeder rekursiven Aufruf die Größe abnehmen muss, d.h. das Problem in kleinere Unterprobleme aufgeteilt werden muss, bis der Basisfall erreicht wird. Schließlich können die Lösungen zusammengeführt werden, um die Hauptproblemlösung zu erhalten, was als divide-conquer- Ansatz bezeichnet wird.

Der Fakultät eines gegebenen Zahlen n ist n! Dies kann mathematisch wie folgt ausgedrückt werden:

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

Es kann auch so gemacht werden, dass die Bezeichner (n-1).(n-2)…3.2.1 zu (n-1)! werden. Also ist der Fakultät eines gegebenen Zahlen immer n.(n-1)!

Nun kann man unten sehen, wie das Problem rekursiv gelöst wird.

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

Der oben stehende Programmcode gibt die Ausgabe folgendermaßen an:
Fakultät von 1: = 1
Fakultät von 2: = 2
Fakultät von 3: = 6
Fakultät von 4: = 24
Fakultät von 5: = 120

Wie du sehen kannst, befindet sich oben ein Objekt namens ‚factorialDemo‘ und innerhalb von ihm eine ‚main‘-Funktion, die einen Schleifen包含 und fünf Mal wiederholt wird. Darin enthält eine Funktionsaufruf auch zu ‚factorial‘, in der eine rekursive Funktion einen rekursiven Aufruf tätigt, d.h., n zu fünf Mal. Es stoppt beim Basispfad, wenn n kleiner gleich 1 ist, und das Ergebnis wird zurückgegeben und ausgegeben.

Anonyme Funktion

Anonyme Funktionen sind leichte Funktionsdefinitionen ohne Namen und werden in Scala als funktionale Literal bezeichnet.

Die Syntax mit einem Beispiel für eine anonyme Funktion ist wie folgt:

  • Die erste Syntax und ein Beispiel für eine anonyme Funktion ist:

Syntax:

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

Beispiel:

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

ODER

  • Die zweite Syntax und ein Beispiel für eine anonyme Funktion ist:

Syntax:

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

Beispiel:

 (_:String)+(_:String)

Die erste Syntax zeigt, dass die Ausdrücke nach „=>“ auf einen bestimmten Wert evaluiert werden, während die Liste der Variablen vor „=>“ verwendet wird, um die Ausdrücke zu evaluieren.

Die zweite Syntax oben funktioniert wie ein Platzhalter, der einmal nur ein Wildcard-Zeichen als Wert akzeptiert und dann unter ihnen operiert.

Sie sehen unten ein Beispiel einer anonymen Funktion:

 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}

                                   ^

Das obige Programm gibt die Ausgabe folgendermaßen aus:
10
10

Es ist zu sehen, dass das Objekt namens ‚anonymousDemo‘ mit der ‚main‘ Funktion zwei anonyme Funktionen enthält. Sie unterscheiden sich syntaktisch, können jedoch das gleiche Ergebnis erzeugen. Bei ‚function1‘ wird die Evaluierung durch die Übergabe von Parametern aus einer Funktionsaufruf erfolgen, da es einfach einfach einmal aufgerufen wird und die Werte 5 und 5 empfängt, die zu einer Ausgabe von 10 führen. Bei ‚function2‘ wird ebenfalls aufgerufen, indem 7 und 3 übergeben werden, die einmal empfangen werden, um beliebige gültige ‚Integer‘ zu接受. In Ihrem Fall sollte die Additionsoperation durchgeführt und das Ergebnis ausgegeben werden.

Fazit

Glückwunsch, Sie haben dieses Tutorial fertig gelesen.

Es gibt viele fortgeschrittene Themen in Scala, wie z.B. höhererordnungsfunktionen, eingebettete Funktionen, kurrierten Funktionen usw.

Quelle:
TOUR DER SCALA-BASICS
Scala | Funktionen – Grundlagen
Scala – Funktionen
Anonyme Funktionen in Scala

Schauen Sie sich DataCamp’s Einführung in Scala Kurs an.

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