Kurs
Einführung in Scala
3 Std.
27.1K
Du möchtest mehr über Scala lernen? Dann starte mit DataCamps Kurs Introduction to Scala.
Scala ist eine funktionale Programmiersprache, in der Funktionen First-Class-Werte sind und daneben auch Methoden existieren – mit Überschneidungen, aber auch Unterschieden. Sowohl Funktionen als auch Methoden sind wiederverwendbare Codeblöcke, mit denen du mehrfach benötigten Code an einer Stelle bündelst und über Aufrufe für konkrete Aufgaben nutzt. Das erleichtert Debugging und Weiterentwicklung.
Funktionen sind Objekte, die einer Variable zugewiesen werden. Methoden hingegen beginnen mit dem Schlüsselwort 'def', gefolgt vom Methodennamen, der Parameterliste und dem Methodenkörper mit Rückgabewert.
Methodendeklaration und -definition
Die Syntax für die Deklaration und Definition einer Methode in Scala sieht so aus:
def 'method_name' ('parameters':'return_type_parameters') : ('return_type_of_method') = {
'method_body'
return 'value'
}
Eine Methode in Scala besteht aus folgenden Teilen:
- 'def': Schlüsselwort zum Deklarieren von Methoden.
- 'method_name': Der Name deiner Methode, in Lower Camel Case.
- 'parameters': Die Parameter der Methode. Es kann keiner, einer oder mehrere sein; mehrere Parameter werden durch Kommas getrennt.
- 'return_type_of_parameters': Muss dem Datentyp der 'parameters_list' entsprechen und ist verpflichtend.
- 'return_type_of_method': Ist optional. Standardmäßig wird 'Unit' zurückgegeben; mit dem Schlüsselwort 'return' kann ein Wert zurückgegeben werden.
- Zuweisungszeichen ('='): Optional. Wenn es verwendet wird, weist es den Rückgabewert zu. Ohne '=' liefert die Methode keinen Rückgabewert.
- 'method_body': Der Codeblock in geschweiften Klammern '{}' mit der Logik bzw. den auszuführenden Operationen.
- return: Schlüsselwort zum Zurückgeben von Werten und Beenden der Ausführung – in Scala eher selten genutzt.
Methodenaufruf
Die Syntax für einen Methodenaufruf in Scala ist:
method_name(arguments)
Ein Methodenaufruf erfolgt über den 'method_name', also den Namen der aufzurufenden Methode, und die zu übergebenden Argumente.
Eine Methode mit benannten Argumenten
Bei benannten Argumenten ordnest du beim Aufruf die übergebenen Werte explizit den Parametern der Methode zu. Jedes Argument wird dabei einem Parameter zugewiesen. Unten siehst du ein Beispiel mit Deklaration, Definition und Aufruf:
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 Programm erzeugt folgende Ausgabe:
Difference of the value is: 2
Difference of the value is: 2
Im Beispiel gibt es ein Objekt 'calculateResult' mit der Methode 'funSub'. Beide Parameter x und y haben den Rückgabetyp 'Int', und auch die Methode selbst gibt 'Int' zurück. Nach dem Gleichheitszeichen folgt der Methodenkörper. In den geschweiften Klammern wird die Variable 'diff' zunächst mit 0 initialisiert. Beim Aufruf 'funSub(8,6)' im 'main' wird 8 an 'x' und 6 an 'y' übergeben, die Subtraktion ausgeführt, 'diff' zurückgegeben und ausgegeben. Beim Aufruf 'funSub(x=8,y=6)' ist die Reihenfolge egal: 8 wird 'x' und 6 'y' zugeordnet, die gleiche Operation wird durchgeführt und das Ergebnis ausgegeben.
Standardwerte für Parameter
Du kannst für Methodenparameter Standardwerte definieren. Dann kannst du beim Aufruf Argumente weglassen.
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 Programm erzeugt folgende Ausgabe:
The final value is: 3
Auch hier enthält das Objekt 'calculateResult' die Methode 'funSub' mit den Parametern x und y vom Typ 'Int' und dem Gesamtrückgabetyp 'Int'. Nach dem Gleichheitszeichen folgt der Methodenkörper, in dem 'diff' auf 0 gesetzt wird. Der Aufruf erfolgt in 'main' über 'funSub()', wodurch x den Standardwert 9 und y den Standardwert 6 erhält. Die Operation wird ausgeführt, 'diff' zurückgegeben und ausgegeben.
Variabel lange Argumentlisten
Variabel lange Argumentlisten erlauben es, eine beliebige Anzahl von Argumenten zu übergeben. Der letzte Parameter der Methode wird mit '*' deklariert und kann wiederholt werden.
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 Programm erzeugt folgende Ausgabe:
Scala
is
great
Das Objekt 'variableArgument' enthält die Methode 'printAll', bei der das variabel lange Argument 'String*' am Ende definiert ist. Beim Aufruf kann eine Liste von Strings übergeben werden. Diese Liste wird iteriert und die Werte werden in der Hauptfunktion ausgegeben.
Rekursive Funktion
Rekursion ist eine Technik der funktionalen Programmierung, bei der ein Problem gelöst wird, indem es wiederholt in kleinere, dem Originalproblem ähnliche Teilprobleme zerlegt wird. Die Teilprobleme werden gelöst und ihre Lösungen kombiniert, um die Gesamtlösung zu erhalten. Das ist der Divide-and-Conquer-Ansatz und führt oft zu sauberem, elegantem Code. Beim Schreiben rekursiver Funktionen sind zwei Punkte entscheidend:
- Basisfall: Es kann mehr als einen Basisfall geben. Wird er nicht korrekt definiert, droht endlose Rekursion. Der Basisfall muss ohne weitere Rekursion eine Lösung liefern.
- Rekursionsfall: Der Fall, in dem die Funktion sich selbst aufruft. Wesentlich ist, dass sich die Problemgröße bei jedem Aufruf verringert, bis der Basisfall erreicht ist. Am Ende werden die Teillösungen zur Gesamtlösung zusammengesetzt.
Die Fakultät einer Zahl n ist n! und lässt sich so ausdrücken:
Die Terme (n-1).(n-2)...3.2.1 sind (n-1)!. Damit gilt: Die Fakultät einer Zahl ist n · (n-1)!
So lässt sich das Problem rekursiv lösen:
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)
}
}
Das Programm erzeugt folgende Ausgabe:
Factorial of 1: = 1
Factorial of 2: = 2
Factorial of 3: = 6
Factorial of 4: = 24
Factorial of 5: = 120
Im Objekt 'factorialDemo' enthält 'main' eine Schleife über die Zahlen 1 bis 5 und ruft jeweils 'factorial' auf. Die rekursive Funktion ruft sich selbst auf, bis der Basisfall n ≤ 1 erreicht ist. Dann wird das Ergebnis zurückgegeben und ausgegeben.
Anonyme Funktion
Anonyme Funktionen sind leichtgewichtige Funktionsdefinitionen ohne Namen und werden in Scala auch als Funktionsliterale bezeichnet.
Syntax und Beispiele für anonyme Funktionen:
- Erste Syntax mit Beispiel:
Syntax:
('first_variable':'data_type', 'second_variable':'data_type') => "certain_expression"
Beispiel:
(var1:String:var2:String) => var1 + var2
ODER
- Zweite Syntax mit Beispiel:
Syntax:
(_:'data_type')operator(_'data_type')
Beispiel:
(_:String)+(_:String)
Bei der ersten Syntax wird der Ausdruck nach "=>" zu einem Wert ausgewertet; die Variablenliste vor "=>" liefert die Werte für die Auswertung.
Die zweite Syntax nutzt Platzhalter. Der Unterstrich fungiert als Wildcard und kann jeweils einmal verwendet werden; der Operator wirkt auf diese Platzhalter.
Ein Beispiel für anonyme Funktionen:
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 Programm erzeugt folgende Ausgabe:
10
10
Im Objekt 'anonymousDemo' definiert die 'main'-Funktion zwei anonyme Funktionen. Sie sind syntaktisch unterschiedlich, liefern aber dasselbe Ergebnis: 'function1' erhält die Parameter direkt aus dem Funktionsaufruf — hier 5 und 5 — und gibt 10 aus. 'function2' wird mit 7 und 3 aufgerufen, akzeptiert gültige Integer-Werte über Platzhalter, addiert sie und gibt das Ergebnis aus.
Fazit
Glückwunsch, du hast dieses Tutorial abgeschlossen.
Es gibt viele weiterführende Scala-Themen wie Higher-Order-Funktionen, geschachtelte Funktionen, Currying und mehr.
Referenzen:
TOUR OF SCALA BASICS
Scala | Functions – Basics
Scala - Functions
Anonymous Functions in Scala
Schau dir auch DataCamps Kurs Introduction to Scala an.
Themen