Scala Kochbuch, 2. Auflage

Vorwort

Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: [e-mail]

Dies ist ein Kochbuch mit Problemlösungsrezepten zu Scala 3, der interessantesten Programmiersprache, die ich je benutzt habe. Das Buch enthält Lösungen für mehr als zweihundertfünfzig gängige Scala-Programmierprobleme, die anhand von mehr als tausend Beispielen demonstriert werden.

Im Vergleich zu anderen Scala 3 Lernressourcen ist dieses Buch in vielerlei Hinsicht einzigartig:

• Als Kochbuch soll es dir Zeit sparen, indem es Lösungen für die häufigsten Probleme bietet, auf die du stoßen wirst.

• Das Buch behandelt nicht nur die Sprache Scala, sondern auch Rezepte für Scala-Tools und -Bibliotheken, darunter sbt, Spark, Scala.js, Akka-Actors und JSON-Verarbeitung mit dem Play Framework.

• Das Buch taucht tief in die Scala-Klassen für Sammlungen ein und demonstriert in fünf Kapiteln deren Verwendung.

• Die Ausgabe der Beispiele wird entweder im Scala-Interpreter oder in den Kommentaren nach dem Code angezeigt. So kannst du, egal ob du am Computer sitzt, im Flugzeug oder in deinem Lieblingssessel liest, die genaue Ausgabe sehen. (Was oft zu der Frage führt: "Ah, so funktioniert das also.")

Die Sprache Scala 3

In der ersten Ausgabe des Scala Cookbook habe ich Scala 2 als eine Kombination aus Ruby und Java beschrieben. Damals schrieb ich: "Mein (stark vereinfachtes) Scala-Elevator-Pitch ist, dass es ein Kind von Ruby und Java ist: Es ist leicht, prägnant und lesbar wie Ruby, aber es kompiliert zu Klassendateien, die du als JAR-Dateien verpackst, die auf der Java Virtual Machine (JVM) laufen; es verwendet Traits und Mixins und fühlt sich dynamisch an, ist aber statisch typisiert."

Seitdem wurden die Eigenschaften von Scala in einem offenen, öffentlichen Prozess neu überdacht und diskutiert. Mit der Veröffentlichung von Scala 3 im Jahr 2021 fühlt sich die Sprache noch leichter an und wirkt nun wie eine Kombination aus vier großartigen Sprachen: Ruby und Java, kombiniert mit der leichten und sauberen Syntax von Python und Haskell.

Ein Teil dieses noch leichteren Gefühls ist der neuen optionalen Klammer-Syntax zu verdanken, die auch als signifikanter Einrückungsstil bekannt ist. Mit dieser einen Änderung sehen for Schleifen, die früher so aussahen:

for (i <- 1 to 5) { println(i) }

sehen jetzt so aus:

for i <- 1 to 5 do println(i)

Auch die if Ausdrücke und viele andere Ausdrücke verwenden eine weniger komplizierte Syntax und sind leichter zu lesen:

val y = if (x == 1) { true } else { false }   // Scala 2
val y = if x == 1 then true else false        // Scala 3

Obwohl diese neue Syntax als optional gilt, ist sie zum De-facto-Standard geworden und wird in diesem Buch, dem Scala 3-Buch, das ich für die Scala-Dokumentations-Website mitgeschrieben habe, den offiziellen Scala 3-Schulungskursen auf Coursera, den Büchern Programming in Scala von Martin Odersky et al. (Artima Press) und Programming Scala von Dean Wampler (O'Reilly) und vielen weiteren Lernressourcen verwendet.

Die neue Syntax ist nicht die einzige Änderung. Scala 3 hat viele neue Funktionen, darunter:

• Aufzählungen

• Vereinigungs- und Kreuzungstypen

• Top-Level-Definitionen (damit dein Code nicht mehr in Klassen, Traits und Objekten enthalten sein muss)

• Vereinfachte Verwendung von Implikaten mit der neuen given und using Syntax

• Stark vereinfachte Syntax für Erweiterungsmethoden und Typklassen

Sogar die Syntax von Traits und Klassen wurde vereinfacht und ist nun besser lesbar als je zuvor:

trait Animal:
    def speak(): Unit

trait HasTail:
    def wagTail(): Unit

class Dog extends Animal, HasTail:
    def speak() = println("Woof")
    def wagTail() = println("⎞⎜⎛  ⎞⎜⎛")

Mit der neuen Syntax wurde jedes Konstrukt, das unnötigen "Lärm" in deinem Code verursacht, entfernt.

Scala Eigenschaften

Zusätzlich zu all dem, was gerade gesagt wurde, bietet Scala eine Vielzahl von Funktionen, die es zu einer einzigartigen und wirklich modernen Programmiersprache machen:

• Sie wurde von Martin Odersky - dem "Vater" von javac- entwickelt und von Java, Ruby, Smalltalk, ML, Haskell, Python, Erlang und anderen beeinflusst.

• Es ist eine Programmiersprache auf hohem Niveau.

• Sie hat eine prägnante, lesbare Syntax - wir nennen sie ausdrucksstark.

• Sie ist statisch typisiert - du genießt also alle Vorteile der statischen Typsicherheit - aber sie fühlt sich an wie eine dynamische Skriptsprache.

• Es ist eine rein objektorientierte Programmiersprache (OOP); jede Variable ist ein Objekt und jeder Operator ist eine Methode.

• Es ist außerdem eine funktionale Programmiersprache (FP), du kannst also Funktionen als Variablen übergeben.

• Die Essenz von Scala ist, wie Herr Odersky es ausdrückt, dass es eine Verschmelzung von FP und OOP in einem typisierten Umfeld ist, mit:

  • Funktionen für die Logik

  • Objekte für die Modularität

• Es läuft auf der JVM und dank des Scala.js-Projekts ist es auch ein typsicherer JavaScript-Ersatz.

• Es interagiert nahtlos mit Java und anderen JVM-Bibliotheken.

• Dank GraalVM und Scala Native kannst du jetzt aus deinem Scala-Code schnell startende native ausführbare Dateien erstellen.

• Die innovative Scala-Sammlungsbibliothek verfügt über Dutzende von vorgefertigten funktionalen Methoden, die dir Zeit sparen und die Notwendigkeit, eigene for Schleifen und Algorithmen zu schreiben, erheblich reduzieren.

• Bewährte Methoden der Programmierung sind in Scala eingebaut, das Unveränderlichkeit, anonyme Funktionen, Funktionen höherer Ordnung, Mustervergleiche, Klassen, die standardmäßig nicht erweitert werden können, und vieles mehr bevorzugt.

• Das Scala-Ökosystem bietet die modernsten FP-Bibliotheken der Welt.

Eine Sache, die ich an Scala liebe, ist, dass du, wenn du mit Java vertraut bist, schon am ersten Tag mit Scala produktiv sein kannst - aber die Sprache ist tiefgründig, so dass du mit der Zeit immer mehr lernst und neue, bessere Wege findest, Code zu schreiben. Scala wird die Art und Weise, wie du über das Programmieren denkst, verändern - und das ist eine gute Sache.

Von allen Vorteilen von Scala gefällt mir am besten, dass du damit prägnanten, lesbaren Code schreiben kannst. Das Verhältnis zwischen der Zeit, die ein Programmierer mit dem Lesen von Code verbringt, und der Zeit, die er mit dem Schreiben von Code verbringt, liegt bei mindestens 10:1, daher ist es wichtig, prägnanten und lesbaren Code zu schreiben.

Scala fühlt sich leicht und dynamisch an

Scala ist nicht nur ausdrucksstark, sondern fühlt sich auch wie eine leichte, dynamische Skriptsprache an. Das Typisierungssystem von Scala macht zum Beispiel das Offensichtliche überflüssig. Anstatt immer Typen angeben zu müssen, weist du deinen Variablen einfach ihre Daten zu:

val hello = "Hello, world"   // a String
val i = 1                    // an Int
val x = 1.0                  // a Double

Beachte, dass es nicht nötig ist, zu deklarieren, dass eine Variable eine String, Int oder Double ist. Das ist Scalas Typ-Inferenz-System bei der Arbeit.

Das Erstellen deiner eigenen benutzerdefinierten Typen funktioniert genau so. Gegeben eine Person Klasse:

class Person(val name: String)

kannst du eine einzelne Person erstellen:

val p = Person("Martin Odersky")

oder mehrere Personen in einer Liste, ohne unnötigen Boilerplate-Code:

val scalaCenterFolks = List(
    Person("Darja Jovanovic"),
    Person("Julien Richard-Foy"),
    Person("Sébastien Doeraene")
)

Und obwohl ich die for Ausdrücke noch nicht eingeführt habe, vermute ich, dass jeder Entwickler mit ein bisschen Erfahrung diesen Code verstehen kann:

for
    person <- scalaCenterFolks
    if person.name.startsWith("D")
do
    println(person.name)

Und auch wenn ich noch keine Enums eingeführt habe, weiß derselbe Entwickler wahrscheinlich, was dieser Code bedeutet:

enum Topping:
    case Cheese, Pepperoni, Mushrooms, Olives

Beachte auch hier, dass es keinen unnötigen Boilerplate-Code gibt; der Code ist so "minimalistisch" wie möglich, aber trotzdem leicht lesbar. Es wurde großer Wert darauf gelegt, die Tradition von Scala als ausdrucksstarke Sprache fortzusetzen.

In all diesen Beispielen kannst du sehen, wie leichtgewichtig die Syntax von Scala ist und wie sie sich wie eine dynamische Skriptsprache anfühlt.

Publikum

Dieses Buch ist für Programmierer/innen gedacht, die schnell Lösungen für Probleme finden wollen, auf die sie bei der Verwendung von Scala und seinen Bibliotheken und Werkzeugen stoßen werden. Ich hoffe, es ist auch ein gutes Werkzeug für Entwickler, die Scala lernen wollen. Ich bin ein großer Verfechter des Lernens anhand von Beispielen, und dieses Buch ist voll von Beispielen.

In der Regel gehe ich davon aus, dass du Erfahrung mit einer anderen Programmiersprache wie C, C++, Java, Ruby, C#, PHP, Python, Haskell oder ähnlichem hast. Ich habe selbst Erfahrung mit diesen Sprachen und bin mir sicher, dass mein Schreiben von diesem Hintergrund beeinflusst wird.

Eine andere Möglichkeit, die Zielgruppe für dieses Buch zu beschreiben, ist die Betrachtung der verschiedenen Ebenen von Softwareentwicklern. In diesem Artikel über Scala-Ebenen definiert Martin Odersky die folgenden Ebenen von Computerprogrammierern:

• Stufe A1: Anfänger in der Anwendungsprogrammierung

• Stufe A2: Fortgeschrittener Anwendungsprogrammierer

• Stufe A3: Experte für Anwendungsprogrammierung

• Stufe L1: Junior-Bibliothekar/in

• Stufe L2: Senior Library Designer

• Level L3: Experte für Bibliotheksgestaltung

Dieses Buch richtet sich in erster Linie an die Anwendungsentwickler der Kategorien A1, A2, A3 und L1. Auch wenn ich in erster Linie diesen Entwicklern helfen möchte, hoffe ich, dass auch Entwickler der Kategorien L2 und L3 von den vielen Beispielen in diesem Buch profitieren können - vor allem, wenn sie noch keine Erfahrung mit funktionaler Programmierung haben oder sich schnell mit Scala und seinen Tools und Bibliotheken vertraut machen wollen.

Inhalt dieses Buches

In diesem Buch dreht sich alles um Lösungen, und Kapitel 1, Kommandozeilenaufgaben, enthält eine Sammlung von Rezepten, die sich um die Verwendung von Scala auf der Kommandozeile drehen. Es beginnt mit Tipps zur Verwendung der Scala REPL und der mit vielen Funktionen ausgestatteten Ammonite REPL. Dann wird gezeigt, wie du mit Kommandozeilen-Tools wie scalac und scala deinen Code kompilierst und ausführst, und wie du mit dem Befehl javap deine Scala-Klassendateien disassemblierst. Zum Schluss wird gezeigt, wie man mit Scala erzeugte JAR-Dateien ausführt.

Kapitel 2, Strings, enthält Rezepte für die Arbeit mit Strings. Scala hat seine grundlegende String Funktionalität von Java übernommen, aber mit der Macht der impliziten Konvertierung fügt Scala Strings neue Funktionen hinzu, sodass du sie auch als eine Folge von Zeichen behandeln kannst (Char values).

Kapitel 3, Zahlen und Daten, enthält Rezepte für die Arbeit mit den numerischen Typen von Scala und den Datumsklassen, die mit Java 8 eingeführt wurden. In den Rezepten für Zahlen wirst du feststellen, dass es keine ++ und -- Operatoren für die Arbeit mit Zahlen gibt; dieses Kapitel erklärt, warum das so ist, und demonstriert die anderen Methoden, die du verwenden kannst. Außerdem wird gezeigt, wie man mit großen Zahlen und Währungen umgeht und wie man Fließkommazahlen vergleicht. Die Rezepte für das Datum verwenden die Java 8 Datumsklassen und zeigen, wie man mit alten Datumsangaben arbeitet.

Kapitel 4, Kontrollstrukturen, demonstriert die in Scala eingebauten Kontrollstrukturen, beginnend mit if/then-Anweisungen und grundlegenden for Schleifen, und bietet dann Lösungen für die Arbeit mit for/yield-Schleifen (for comprehensions) und for Ausdrücken mit eingebetteten if Anweisungen (guards). Da match Ausdrücke und Mustervergleiche so wichtig für Scala sind, zeigen mehrere Rezepte, wie man sie zur Lösung verschiedener Probleme einsetzt.

Kapitel 5, Klassen, enthält Beispiele für Scala-Klassen, -Parameter und -Felder. Da sich Scala-Konstruktoren stark von Java-Konstruktoren unterscheiden, zeigen mehrere Rezepte, wie man sowohl Primär- als auch Hilfskonstruktoren schreibt. Mehrere Rezepte zeigen, was case Klassen sind und wie man sie benutzt.

Kapitel 6, Traits und Enums, enthält Beispiele für den wichtigen Scala-Trait sowie den brandneuen enum. Die Trait-Rezepte zeigen zunächst, wie ein Trait wie eine Java-Schnittstelle verwendet wird, und gehen dann auf fortgeschrittenere Themen ein, wie z. B. die Verwendung von Traits als Mixins und die Begrenzung der Member, in die ein Trait mit verschiedenen Methoden gemischt werden kann. Die letzten beiden Rezepte zeigen, wie Enums in der Domänenmodellierung verwendet werden können, einschließlich der Erstellung von algebraischen Datentypen (ADTs).

Kapitel 7, Objekte, enthält Rezepte zu Objekten, einschließlich der Bedeutung eines Objekts als Instanz einer Klasse, sowie alles, was mit dem Schlüsselwort object zusammenhängt.

Kapitel 8, Methoden, zeigt, wie man Methoden so definiert, dass sie Parameter akzeptieren, Werte zurückgeben, Parameternamen beim Methodenaufruf verwenden, Standardwerte für Methodenparameter festlegen, varargs-Felder erstellen und Methoden schreiben, um einen flüssigen Programmierstil zu unterstützen. Das letzte Rezept des Kapitels demonstriert die brandneuen Scala 3 Erweiterungsmethoden.

Kapitel 9, Paketierung und Importe, enthält Beispiele für die Anweisungen package und import von Scala, die mehr Möglichkeiten bieten als die gleichen Java-Schlüsselwörter. Hier erfährst du, wie du die geschweifte Klammer für die Paketierung verwendest, wie du Mitglieder ausblenden und umbenennen kannst, wenn du sie importierst, und vieles mehr.

Obwohl ein Großteil des Buches FP-Techniken demonstriert, fasst Kapitel 10, Funktionale Programmierung, viele FP-Rezepte an einer Stelle zusammen. Die Lösungen zeigen, wie man anonyme Funktionen (Funktionsliterale) definiert und sie in einer Vielzahl von Situationen einsetzt. Die Rezepte zeigen, wie man eine Methode definiert, die ein Funktionsargument annimmt, wie man Funktionen teilweise anwendet und wie man eine Funktion aus einer Funktion zurückgibt.

Die Scala-Sammlungsbibliothek ist reichhaltig und tiefgründig. In den Kapiteln 11 bis 15 findest du daher Hunderte von Beispielen für Sammlungen.

Die Rezepte in Kapitel 11, Sammlungen: Einführung helfen dir bei der Auswahl von Sammlungsklassen für bestimmte Bedürfnisse und dann bei der Auswahl und Verwendung von Methoden innerhalb einer Sammlung, um bestimmte Probleme zu lösen, z. B. die Umwandlung einer Sammlung in eine neue Sammlung, das Filtern einer Sammlung und das Erstellen von Untergruppen einer Sammlung.

Kapitel 12, Sammlungen: Common Sequence Classes (Gemeinsame Sequenzklassen) demonstriert die gebräuchlichsten Sammlungsklassen, darunter Vector, List, ArrayBuffer, Array, und LazyList. In den Rezepten wird gezeigt, wie man die einzelnen Typen erstellt und wie man Elemente hinzufügt, aktualisiert und entfernt.

Kapitel 13, Sammlungen: Gemeinsame Methoden für Sequenzen zeigt, wie du die gängigsten Methoden für die Scala-Sequenzklassen verwendest. Die Rezepte zeigen, wie man über Sequenzen iteriert, sie transformiert, filtert, sortiert und vieles mehr.

Genauso wie das vorherige Kapitel gängige Sequenzmethoden demonstriert, zeigt Kapitel 14, Sammlungen: Verwendung von Maps zeigt viele der gleichen Techniken für die Verwendung mit Scala Map Klassen.

Kapitel 15 schließlich , Sammlungen: Tupel, Range, Set,Stack und Queue werden die anderen Scala-Sammlungsklassen behandelt, darunter Tupel, Ranges, Sets, Stacks und Queues.

Kapitel 16, Dateien und Prozesse, zeigt, wie man mit Dateien und Prozessen arbeitet. In den Rezepten wird gezeigt, wie man Dateien liest und schreibt, Verzeichnislisten abruft und mit Serialisierung arbeitet. Mehrere Rezepte zeigen dann, wie man plattformunabhängig mit externen Prozessen arbeitet.

Kapitel 17, Projekte mit sbt bauen, ist ein umfassender Leitfaden für das De-facto-Build-Tool für Scala-Anwendungen. Zunächst werden verschiedene Möglichkeiten aufgezeigt, wie du eine sbt-Projektverzeichnisstruktur erstellst, und dann wird gezeigt, wie du verwaltete und nicht verwaltete Abhängigkeiten einbindest, deine Projekte baust, Scaladoc für deine Projekte generierst, deine Projekte bereitstellst und vieles mehr.

Kapitel 18, Gleichzeitigkeit mit Scala Futures und Akka Actors, bietet Lösungen für die wunderbare Welt des Aufbaus nebenläufiger Anwendungen (und die Auslastung der Multicore-CPUs!) mit Futures und der Akka Actors-Bibliothek. Die Rezepte mit Futures zeigen, wie man einmalige, kurzlebige Nebenläufigkeiten aufbaut, während die Actors-Rezepte zeigen, wie man langlebige parallele Prozesse erstellt, die während ihrer Lebensdauer auf Milliarden von Anfragen reagieren können.

Kapitel 19, Play Framework und Webdienste, zeigt, wie man Scala sowohl auf der Client- als auch auf der Serverseite von Webdiensten einsetzt. Auf der Serverseite wird gezeigt, wie man das Play Framework zur Entwicklung von RESTful-Webdiensten verwendet. Sowohl für den Client- als auch für den Servercode wird gezeigt, wie man JSON serialisiert und deserialisiert und wie man mit HTTP-Headern arbeitet.

In Kapitel 20, Apache Spark, wird das Apache Spark-Framework vorgestellt. Spark ist eine der Anwendungen, die Scala berühmt gemacht haben. In den Rezepten wird gezeigt, wie man mit großen Datensätzen als Resilient Distributed Dataset (RDD) arbeitet und wie man sie mit branchenüblichen SQL-Abfragen abfragt.

Kapitel 21, Scala.js, GraalVM und jpackage enthält mehrere Rezepte für Bibliotheken und Werkzeuge in der Scala- und JVM-Welt. Die ersten Rezepte zeigen, wie du Scala.js als typsicheren JavaScript-Ersatz verwenden kannst. Die letzten Rezepte zeigen, wie du deinen Scala-Code mit GraalVM in eine native ausführbare Datei umwandelst und wie du deine Scala-Anwendung mit dem Java-Dienstprogramm jpackage als native Anwendung verpacken kannst.

Kapitel 22, Integration von Scala mit Java, zeigt, wie du die wenigen Probleme lösen kannst, die bei der Integration von Scala- und Java-Code auftreten können. Obwohl Scala-Code oft einfach funktioniert, wenn er mit Java interagiert, gibt es ein paar "Probleme". In diesem Kapitel wird gezeigt, wie du Probleme im Zusammenhang mit den Unterschieden in den Sammlungsbibliotheken lösen kannst und welche Probleme beim Aufruf von Scala-Code aus Java auftreten können.

Kapitel 23, Typen, enthält Rezepte für die Arbeit mit dem leistungsstarken Typsystem von Scala. Gleich in der Einleitung werden Konzepte wie Typabweichung, Grenzen und Beschränkungen anhand von Beispielen demonstriert. Die Rezepte zeigen, wie man Generics in Klassen- und Methodendefinitionen deklariert, Duck Typing implementiert und kontrolliert, in welche Typen deine Traits gemischt werden können. Dann werden einige völlig neue Scala 3-Konzepte mit undurchsichtigen Typen, given`and `using -Werten als Ersatz für Implicits, Union- und Intersection-Typen und zwei Rezepten zum Konzept der Gleichheit beim Vergleich von Objekten vorgestellt.

Kapitel 24, Bewährte Methoden, ist einzigartig für ein Kochbuch, aber da es sich um ein Buch mit Lösungen handelt, halte ich es für wichtig, dass ein Abschnitt den bewährten Methoden gewidmet ist, d.h. wie man Code "auf die Scala-Art" schreibt. Die Rezepte zeigen, wie man Methoden ohne Seiteneffekte erstellt, wie man mit unveränderlichen Objekten und Auflistungstypen arbeitet, wie man in Ausdrücken (statt in Anweisungen) denkt, wie man Mustervergleiche verwendet und wie man Nullwerte in seinem Code eliminiert.

Scala installieren

Du kannst Scala 3 auf verschiedene Arten installieren: Homebrew (unter macOS), Coursier, SDKMAN und das manuelle Herunterladen und Installieren von Scala. Coursier gilt als der "Scala-Installer" und seine Verwendung wird auf dieser Seite "Erste Schritte mit Scala 3" beschrieben.

Wenn du Scala noch nicht installieren möchtest, kannst du es auch mit diesen Online-Tools in deinem Browser ausprobieren:

• Scastie

• ScalaFiddle

Konventionen in diesem Buch

Es gibt ein paar wichtige Punkte, die du über die Konventionen wissen solltest, die ich in diesem Buch verwende. Erstens verwende ich, wie bereits erwähnt, den Programmierstil der optionalen geschweiften Klammern (signifikante Einrückung), wodurch Klammern und geschweifte Klammern weitgehend überflüssig werden:

for i <- 1 to 5 do println(i)      // use this style
for (i <- 1 to 5) { println(i) }   // don’t use this style

Zusammen mit diesem Stil rücke ich meinen Code mit vier Leerzeichen ein. Derzeit gibt es keinen Standard für die Einrückung, und die Entwickler scheinen zwei bis vier Leerzeichen zu bevorzugen.

Wenn ich Beispiele zeige, zeige ich oft auch das Ergebnis meiner Beispiele in den Kommentaren nach den Beispielen. Deshalb sehen meine Beispiele so aus:

(1 to 10 by 2).toList      // List(1, 3, 5, 7, 9)
(1 until 10 by 2).toList   // List(1, 3, 5, 7, 9)
('d' to 'h').toList        // List(d, e, f, g, h)
('d' until 'h').toList     // List(d, e, f, g)

Dieser Stil hilft mir, viel mehr Beispiele in dieses Buch aufzunehmen, als ich in der ersten Ausgabe unterbringen konnte.

Andere in diesem Buch verwendete Kodierungsstandards sind:

• Ich definiere Variablen immer als val Felder (das ist wie final in Java), es sei denn, es gibt einen Grund, warum sie ein var sein müssen.

• Wenn eine Methode keine Parameter benötigt und einen Nebeneffekt hat (z.B. die Ausgabe auf der Konsole), definiere und rufe ich die Methode mit leeren Klammern auf, wie ().

• Obwohl es in vielen Situationen nicht notwendig ist, Datentypen zu definieren, deklariere ich immer den Rückgabetyp von öffentlichen Methoden.

Als Beispiel für den letzten Standard kannst du eine Methode definieren, ohne ihren Rückgabetyp zu deklarieren, wie hier:

def double(i: Int) = i * 2

Die meisten Entwickler ziehen es jedoch vor, den Rückgabetyp der Methode anzuzeigen:

def double(i: Int): Int = i * 2

Für ein paar Zeichen mehr, die du jetzt tippen musst, wird dein Code später leichter zu lesen sein.

Unterstütze

Viele der in diesem Buch gezeigten Quellcode-Beispiele sind in diesem GitHub-Repository verfügbar, das viele vollständige sbt-Projekte enthält:

• github.com/alvinj/ScalaCookbook2Examples

Der Scala Gitter-Kanal ist eine ausgezeichnete Quelle für Hilfe, und du wirst dort gelegentlich meine Fragen sehen.

Wenn du dich für Vorschläge und Debatten über Scala-Funktionen interessierst, ist die "Scala Contributors"-Website ebenfalls eine hervorragende Ressource.

Meine neuesten Blogbeiträge findest du unter alvinalexander.com, und ich twittere oft über Scala-Themen unter twitter.com/alvinalexander.

In diesem Buch verwendete Konventionen

In diesem Buch werden die folgenden typografischen Konventionen verwendet:

Kursiv

Weist auf neue Begriffe, URLs, E-Mail-Adressen, Dateinamen und Dateierweiterungen hin.

Constant width

Wird für Programmlistings sowie innerhalb von Absätzen verwendet, um auf Programmelemente wie Variablen- oder Funktionsnamen, Datenbanken, Datentypen, Umgebungsvariablen, Anweisungen und Schlüsselwörter hinzuweisen.

Constant width italic

Zeigt Text an, der durch vom Benutzer eingegebene Werte oder durch kontextabhängige Werte ersetzt werden soll.

Tipp

Dieses Element steht für einen Tipp oder eine Anregung.

Hinweis

Dieses Element steht für einen allgemeinen Hinweis.

Warnung

Dieses Element weist auf eine Warnung oder einen Warnhinweis hin.

Code-Beispiele verwenden

Zusätzliches Material (Code-Beispiele, Übungen usw.) steht unter https://github.com/alvinj/ScalaCookbook2Examples zum Download bereit .

Wenn du eine technische Frage oder ein Problem mit den Codebeispielen hast, schicke bitte eine E-Mail an [e-mail].

Dieses Buch soll dir helfen, deine Arbeit zu erledigen. Wenn in diesem Buch Beispielcode angeboten wird, darfst du ihn in deinen Programmen und deiner Dokumentation verwenden. Du musst uns nicht um Erlaubnis fragen, es sei denn, du reproduzierst einen großen Teil des Codes. Wenn du zum Beispiel ein Programm schreibst, das mehrere Teile des Codes aus diesem Buch verwendet, brauchst du keine Erlaubnis. Der Verkauf oder die Verbreitung von Beispielen aus O'Reilly-Büchern erfordert jedoch eine Genehmigung. Die Beantwortung einer Frage mit einem Zitat aus diesem Buch und einem Beispielcode erfordert keine Genehmigung. Wenn du einen großen Teil des Beispielcodes aus diesem Buch in die Dokumentation deines Produkts aufnimmst, ist eineGenehmigung erforderlich.

Wir freuen uns über eine Namensnennung, verlangen sie aber in der Regel nicht. Eine Quellenangabe umfasst normalerweise den Titel, den Autor, den Verlag und die ISBN. Ein Beispiel: "Scala Cookbook von Alvin Alexander (O'Reilly). Copyright 2021 Alvin Alexander, 978-1-492-05154-1."

Wenn du der Meinung bist, dass deine Verwendung von Codebeispielen nicht unter die Fair-Use-Regelung oder die oben genannte Erlaubnis fällt, kannst du uns gerne unter [e-mail] kontaktieren .

O'Reilly Online Learning

Hinweis

Seit mehr als 40 Jahren bietet O'Reilly Media Schulungen, Wissen und Einblicke in Technologie und Wirtschaft, um Unternehmen zum Erfolg zu verhelfen.

Unser einzigartiges Netzwerk von Experten und Innovatoren teilt sein Wissen und seine Erfahrung durch Bücher, Artikel und unsere Online-Lernplattform. Die Online-Lernplattform von O'Reilly bietet dir On-Demand-Zugang zu Live-Trainingskursen, ausführlichen Lernpfaden, interaktiven Programmierumgebungen und einer umfangreichen Text- und Videosammlung von O'Reilly und über 200 anderen Verlagen. Weitere Informationen erhältst du unter http://oreilly.com.

Wie du uns kontaktierst

Bitte richte Kommentare und Fragen zu diesem Buch an den Verlag:

• O'Reilly Media, Inc.
• 1005 Gravenstein Highway Nord
• Sebastopol, CA 95472
• 800-998-9938 (in den Vereinigten Staaten oder Kanada)
• 707-829-0515 (international oder lokal)
• 707-829-0104 (Fax)

Wir haben eine Webseite für dieses Buch, auf der wir Errata, Beispiele und zusätzliche Informationen auflisten. Du kannst diese Seite unter https://oreil.ly/scala-cookbook-2e aufrufen .

Schreib eine E-Mail an [e-mail], um Kommentare oder technische Fragen zu diesem Buch zu stellen.

Neuigkeiten und Informationen über unsere Bücher und Kurse findest du unter https://oreilly.com.

Finde uns auf Facebook: https://facebook.com/oreilly

Folge uns auf Twitter: https://twitter.com/oreillymedia

Schau uns auf YouTube: https://youtube.com/oreillymedia

Danksagungen

Ein so umfangreiches Buch zu schreiben, erfordert eine Menge Arbeit und ich möchte meinem Redakteur Jeff Bleiel für seine Arbeit während der Erstellung dieses Buches danken. Wir begannen im Dezember 2018 mit der Arbeit an dem Buch, und während sich Scala 3 im Laufe des Community-Prozesses immer wieder veränderte, arbeiteten wir bis zur Fertigstellung des Buches im Jahr 2021 gemeinsam daran.

Als ich die ersten Entwürfe der Kapitel fertigstellte, machte Jeff Hunderte von Vorschlägen, wie ich sie verbessern könnte. Dieser Prozess setzte sich während der COVID-19-Pandemie fort, und als das Buch klarer wurde, schlug Jeff (richtigerweise) die Umstrukturierung mehrerer Kapitel vor. Er ist unglaublich gründlich, und ich kann dir sagen: Wenn du ein Buch siehst, das von Jeff Bleiel bearbeitet wurde, kannst du sicher sein, dass es gut bearbeitet und durchdacht ist.

Bei dieser Ausgabe des Buches waren alle Rezensenten auf unterschiedliche Weise hilfreich. Jason Swartz war bereits bei der ersten Ausgabe des Scala Cookbook ein Kandidat für den Titel "wertvollster Rezensent", und auch bei dieser Ausgabe hat er mit vielen guten Vorschlägen hervorragende Arbeit geleistet.

Philip Schwarz hat an dieser Ausgabe mitgewirkt und uns eine Reihe guter Einblicke gegeben, vor allem zu den ersten Kapiteln des Buches.

Aber für diese Ausgabe schulde ich Hermann Hueck einen großen und besonderen Dank, denn er war der wertvollste Rezensent für diese Ausgabe. Hermann hat Hunderte von kleinen und großen Vorschlägen gemacht, die von der kleinsten Codezeile bis zur Gesamtorganisation des Buches reichten.

Ich kann nicht genug über Jeff und Hermann sagen, aber vielleicht ist es am besten, wenn ich sage, dass dieses Buch ohne sie nicht dasselbe gewesen wäre - danke euch beiden!

Ich möchte mich auch bei Christopher Faucher bedanken, dem Produktionslektor dieses Buches. Nachdem Jeff und ich uns darauf geeinigt hatten, dass wir mit dem Schreiben und Redigieren fertig sind, kam Chris ins Spiel und half uns, das Buch fertigzustellen, während wir Hunderte von Kommentaren und Problemen durcharbeiteten. Wenn du weißt, wie es ist, eine große Softwareanwendung zum Leben zu erwecken, dann ist es genau dasselbe, ein großes Buch wie dieses über die Ziellinie zu bringen. Vielen Dank, Chris!

Abschließend möchte ich mich bei Martin Odersky und seinem Team dafür bedanken, dass sie eine so interessante Programmiersprache entwickelt haben. Ich habe mich zum ersten Mal in Scala verliebt, als ich 2010 in einer Buchhandlung in Anchorage, Alaska, sein Buch Programming in Scala entdeckte. Seitdem ist es ein Liebesfest, das bis zu Scala 3 im Jahr 2021 und darüber hinaus anhält.

Ich wünsche dir alles Gute,
Al