Ich lerne Scala – Tag 2

3 minute read Published:

Dieser Artikel stammt aus meinen früheren Wordpress-Instanzen und steht hier aus Gründen der Nostalgie.

Heute geht es richtig los mit Scala. Naja, nicht so wirklich, aber ich habe schon mehr Code geschrieben als beim letzten Mal. Ich hangele mich am Tutorial von „Programming in Scala“ entlang, und habe heute Kapitel 2 durchgearbeitet. Dieses Kapitel zeigt in 6 einfachen Schritten die Grundlegende Syntax der Sprache.

Den Anfang macht ein wenig Gespiele auf der Scala-Shell. Ich habe hier gelernt, dass man eine Variable, Konstanten und Funktionen so definiert:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Kommentar bis zum Zeilenende

/* Kommentar bis hier */

/*
Kommentar über mehre Zeilen
*/


// Eine Konstante namens pi,
// bzw. eine finale Variable
// vom Typ scala.Double
val pi = 3.14

// Eine Variable namens x
// mit dem initialen Wert 0
// vom Typ scala.Int
var x =

// Eine Funktion mit einem
// BigInt-Argument
// die BigInt zurückliefert.
// Sie Berechnet die zweite
// Potenz des Eingabewerts
def pow(x: BigInt): BigInt = x * x

 

Mit der Scala-Shell hat man nebenbei auch einen programmierbaren Taschenrechner. Die Shell kann Tab-Vervollständigung und hat eine Eingabehistorie. Aber das nur am Rande. 🙂

Etwas größer geht es mit Skriptdateien. 🙂 Traditionell lauten die Sourcecode-Dateien auf die Endung .scala, also bspw. hello.scala. Im Gegensatz zu Java werden Anweisungen, die in einer .scala-Datei stehen, direkt ausgeführt, es ist also nicht nötig eine Methode mit der Signatur public static void main(String args[]) zu definieren. Ferner steht das args-Array in -scala-Dateien direkt als args zur Verfügung.

Beispiel: helloarg.scala

1
println("Hello, " + args())

Arrays sind 0-basiert, also kein Unterschied zu Java. Was allerdings ein Unterschied ist, sind die runden Klammern. Betrachtet man allerdings die Tatsache, dass der Zugriff auf ein Array auch nur eine Funktion ist – es ist ein Ausdruck der abhängig vom Funktionswert etwas anderes zurückliefert – dann macht diese Notation richtig Sinn und man fragt sich, wie man es jemals anders hat ertragen können. 🙂

while-Schleifen gibt es mit der identischen Semanatik wie in Java. Aber Scala wäre nicht Scala, wenn es nicht eine schönere funktionale Variante der klassischen imperativen Schleifen gäbe.

Arrays und Collections definieren z.B. ein foreach-Funktion. Diese erwartet eine Funktion – Funktionen sind ja auch nur Objekte und können als Parameter an andere Funktionen übergeben werden – und führt diese Funktion für jedes Element in der Datenstruktur aus. Eine solche Funktion wird landläufig als Closure bezeichnet.

Beispiel: printargs.scala

1
args.foreach(arg => println(arg))

gibt jedes Kommandozeilenargument in einer Zeile aus.

Diesen Ausdruck gibt es auch noch kürzer, nämlich:

Beispiel: printargsminimal.scala

1
args.foreach(println)

Das ist dann möglich, wenn die nur ein Parameter an den Closure übergeben wird und die aufgerufene Funktion auch nur einen Parameter erwartet.

Neben der Funktion forearch, die zuallererst ein Objekt erwartet auf der dem sie aufgerufen wird, gibt es auch ein for-Konstrukt. Dieses sieht so aus:

Beispiel: printforargs.scala

1
2
for (arg <- args) m
println(arg)

Das war der kurze Überblick, wen ich aus dem zweiten Kapitel bekommen habe.