Scala (Programmiersprache)

Scala

Paradigma	Multi-Paradigma: gleichzeitig, funktional, Imperativ, objektorientierter
Entworfen von	Martin Odensky
Entwickler	Programmiermethoden Labor von École Polytechnique Fédérale de Lausanne
Erstmals erschienen	20. Januar 2004; Vor 18 Jahren
Stabile Version	3.1.1[1]  / 21. Januar 2022; vor 6 Monaten
Vorschau -Version	3.1.1-RC1[2]  / 18. Oktober 2021; vor 9 Monaten
Disziplin tippen	Gefolgert, statisch, stark, strukturell
Implementierungssprache	Scala
Plattform	Java virtuelle Maschine (JVM) JavaScript (Scala.js) Llvm (Scala geboren) (experimentell)
Lizenz	Apache 2.0[3]
Dateiname -Erweiterungen	.Scala, .Sc
Webseite	www.Scala-Lang.org
Beeinflusst von
Common Lisp,[4] Eiffel, Erlang, F#, Haskell,[5] Java,[6] Ocaml,[6] Oz, Pizza,[7] Planen,[6] Smalltalk, Standard ml[6]
Beeinflusst
Ceylon, Meißel, Fantom, F#, Kotlin, Lasso, Rot, Flix
Scala in Wikibooks

Scala (/ˈskːlː/ Skah-lah)^[8] ist ein stark statisch typisiert Allzweckprogrammiersprache was beides unterstützt Objekt orientierte Programmierung und Funktionelle Programmierung. Entworfen, um präzise zu sein,^[9] Viele der Entwurfsentscheidungen von Scala sollen sich angehen lassen Kritik an Java.^[7]

Der Scala -Quellcode kann zusammengestellt werden Java -Bytecode und rennen auf einem Java virtuelle Maschine (JVM). Scala kann auch zusammengestellt werden JavaScript in einem Browser oder direkt an eine native ausführbare Datei ausführen. Auf dem JVM Scala sorgt Sprachinteroperabilität mit Java so dass in beiden Sprachen geschriebene Bibliotheken direkt in Scala- oder Java -Code verwiesen werden.^[10] Wie Java ist Scala objektorientierterund verwendet a Syntax bezeichnet geschweifte Klammer Welches ist der Sprache ähnlich C. Seit Scala 3 gibt es auch eine Option, die zu verwenden Off-Side-Regel (Einrückung) zur Struktur Blöckeund seine Verwendung wird empfohlen. Martin Odensky hat gesagt, dass dies die in Scala 3 eingeführte produktivste Veränderung ist.^[11]

Im Gegensatz zu Java hat Scala viele Merkmale von Funktionelle Programmierung Sprachen (wie Planen, Standard ml, und Haskell), einschließlich Currying, Unveränderlichkeit, faule Bewertung, und Musteranpassung. Es verfügt auch über ein fortschrittliches Typsystem unterstützt Algebraische Datentypen, Kovarianz und Kontravarianz, Typ höherer Ordnung (aber nicht Typ mit höherem Rang), Anonyme Typen, Bedienerüberlastung, optionale Parameter, Namens Parameter, rohe Saitenund eine experimentelle Ausnahmeversion von algebraischen Effekten, die als leistungsstärkere Version von Java's angesehen werden können Überprüfte Ausnahmen.^[12]

Der Name Scala ist ein Portmanteau von skalierbar und Sprache, was bedeutet, dass es mit den Anforderungen seiner Benutzer wachsen soll.^[13]

Geschichte

Das Design von Scala begann 2001 am École Polytechnique Fédérale de Lausanne (EPFL) (in Lausanne, Schweiz) durch Martin Odensky. Es folgte von der Arbeit am Trichter, einer Programmiersprache, die Ideen aus funktionaler Programmierung kombiniert und Petri Nets.^[14] Odensky arbeitete früher daran Generisches Java, und Javac, Suns Java -Compiler.^[14]

Nach einer internen Veröffentlichung Ende 2003 wurde Scala Anfang 2004 öffentlich veröffentlicht Java -Plattform,^{[15][7][14][16]} Eine zweite Version (v2.0) folgte im März 2006.^[7]

Am 17. Januar 2011 gewann das Scala-Team ein Fünfjahresforschungsstipendium von über 2,3 Millionen Euro von der Europäischer Forschungsrat.^[17] Am 12. Mai 2011 starteten Odensky und Mitarbeiter TypeSafe Inc. (später umbenannt Lightbend Inc.), ein Unternehmen, um kommerzielle Unterstützung, Schulung und Dienstleistungen für Scala zu bieten. TypeSafe erhielt 2011 eine Investition von 3 Millionen US -Dollar von 2011 von Greylock Partners.^{[18][19][20][21]}

Plattformen und Lizenz

Scala läuft auf der Java -Plattform (Java virtuelle Maschine) und ist kompatibel mit vorhanden Java Programme.^[15] Wie Android Anwendungen sind typischerweise in Java geschrieben und aus Java -Bytecode in übersetzt in Dalvik Bytecode (die während der Installation weiter in den nativen Maschinencode übersetzt werden kann), macht die Java-Kompatibilität von Scala für Android-Entwicklung gut geeignet, insbesondere wenn ein funktionaler Ansatz bevorzugt wird.^[22]

Die Referenz -Scala -Softwareverteilung, einschließlich Compiler und Bibliotheken, wird unter dem veröffentlicht Apache -Lizenz.^[23]

Andere Compiler und Ziele

Scala.js ist ein Scala -Compiler, der JavaScript kompiliert und es möglich macht, Scala -Programme zu schreiben, die in Webbrowsern ausgeführt werden können oder Node.js.^[24] Der seit 2013 in der Entwicklung befindliche Compiler wurde 2015 als nicht mehr experimentell angekündigt (V0.6). Version V1.0.0-M1 wurde im Juni 2018 und Version 1.1.1 im September 2020 veröffentlicht.^[25]

Der in Scala geborene ist ein Scala Compiler das zielt auf das ab Llvm Compiler -Infrastruktur zum Erstellen von ausführbarem Code, der eine leichte, verwaltete Laufzeit verwendet, die das verwendet Boehm Garbage Collector. Das Projekt wird von Denys Shabalin geleitet und hatte am 14. März 2017 seine erste Veröffentlichung, 0.1 Just-in-Time-Zusammenstellung Für das JVM, indem die anfängliche Laufzeit -Zusammenstellung von Code eliminiert und auch native Routinen direkt aufgerufen werden kann.^[26][27]

Ein Referenz -Scala -Compiler, der auf die abzielt .NET Framework und sein Gemeinsame Sprachlaufzeit wurde im Juni 2004 veröffentlicht,^[14] wurde aber 2012 offiziell fallen gelassen.^[28]

Beispiele

Beispiel "Hallo Welt"

Das Hallo Weltprogramm Geschrieben in Scala 3 hat diese Form:

@hauptsächlich def hauptsächlich() = {  println("Hallo Welt!") } 

im Gegensatz zu den eigenständige Hello World-Anwendung für JavaEs gibt keine Klassenerklärung und nichts wird als statisch erklärt; a Singleton -Objekt erstellt mit dem Objekt Keyword wird stattdessen verwendet.

Wenn das Programm in der Datei gespeichert ist HelloWorld.scala, der Benutzer kompiliert es mit dem Befehl:

$ scalac helloWorld.scala

und leitet es mit

$ scala helloWorld

Dies ist analog zum Prozess zum Kompilieren und Ausführen von Java -Code. In der Tat ist Scalas Kompilien- und Ausführungsmodell identisch mit dem von Java, was es mit Java -Build -Tools wie kompatibel macht Apache Ant.

Eine kürzere Version des Scala -Programms "Hello World" lautet:

println("Hallo Welt!") 

Scala enthält eine interaktive Shell- und Skriptunterstützung.^[29] In einer Datei benannt gespeichert HelloWorld2.scalaDies kann als Skript mit dem Befehl ausgeführt werden:

$ scala helloWorld2.scala

Befehle können auch direkt in den Scala -Interpreter mit der Option eingegeben werden -e:

$ scala -e "println (" Hallo, Welt! ") '

Ausdrücke können interaktiv in die eingegeben werden Wiederholung:

$ ScalaWillkommen bei Scala 2.12.2 (Java Hotspot (TM) 64-Bit-Server VM, Java 1.8.0_131). Geben Sie Ausdrücke zur Bewertung ein. Oder versuchen Sie: Hilfe. Scala> Liste (1, 2, 3) .Map (x => x * x) Res0: Liste [int] = Liste (1, 4, 9) scala> 

Grundlegendes Beispiel

Das folgende Beispiel zeigt die Unterschiede zwischen Java und Scala -Syntax. Die Funktion Mathfunction erfordert eine Ganzzahl, Quadrate und fügt dann die Würfelwurzel dieser Zahl zu dem natürlichen Protokoll dieser Zahl hinzu, wobei das Ergebnis zurückgegeben wird (d. H., ${\ displayStyle n^{2/3}+\ ln (n^{2})}$):

// Java: int Mathematik(int num) {  int NumSquare = num*num;  Rückkehr (int) (Mathematik.CBRT(NumSquare) +  Mathematik.Protokoll(NumSquare)); } 

// Scala: Direkte Konvertierung von Java // kein Import benötigt; scala.math // bereits als "math" importiert def Mathematik(num: Int): Int = {  var NumSquare: Int = num*num  Rückkehr (Mathematik.CBRT(NumSquare) + Mathematik.Protokoll(NumSquare)).  Asinstance von[Int] } 

// scala: idiomatischer // verwendet Typ -Inferenz, lässt `return` Anweisung aus, aus. // verwendet "Toint" -Methode, erklärt Numsquare unveränderlich importieren Mathematik._ def Mathematik(num: Int) = {  val NumSquare = num*num  (CBRT(NumSquare) + Protokoll(NumSquare)).Toint } 

Einige syntaktische Unterschiede in diesem Code sind:

• Scala verlangt keine Semikolone, um Aussagen zu beenden.
• Werttypen werden aktiviert: Int, doppelt, boolean Anstatt von int, doppelt, boolean.
• Parameter- und Rückgabetypen folgen wie in Pascal, anstatt vorzugehen wie in C.
• Methoden müssen vorangestellt werden def.
• Lokale oder Klassenvariablen müssen von vorangegangen werden val (Zeigt an an unveränderlich Variable) oder var (Zeigt a an veränderlich Variable).
• Das Rückkehr Der Bediener ist in einer Funktion nicht erforderlich (obwohl erlaubt); Der Wert der zuletzt ausgeführten Anweisung oder Ausdruck ist normalerweise der Wert der Funktion.
• Anstelle des Java -Gussbetreibers (Typ) Foo, Scala verwendet foo.asinstanceof [Typ], oder eine spezielle Funktion wie z. verdoppeln oder Toint.
• Anstelle von Javas foo.*importieren;, Scala verwendet foo._ importieren.
• Funktion oder Methode foo () kann auch als gerecht genannt werden Foo; Methode Thread.Send (Signo) kann auch als gerecht genannt werden Thread senden Signo; und Methode foo.tostring () kann auch als gerecht genannt werden foo tostring.

Diese syntaktischen Relaxationen sind so konzipiert, dass sie Unterstützung für die Unterstützung ermöglichen Domänenspezifische Sprachen.

Einige andere grundlegende syntaktische Unterschiede:

• Array -Referenzen werden wie Funktionsaufrufe geschrieben, z. Array (i) statt Array [i]. (Innerlich in Scala erweitert er erstere in Array.Apply (i), was die Referenz zurückgibt)
• Generische Typen sind wie z. Liste [String] eher als Javas Aufführen.
• Anstelle des Pseudo-Typs Leere, Scala hat das tatsächliche Singleton -Klasse Einheit (siehe unten).

Beispiel mit Klassen

Das folgende Beispiel^{[Klarstellung erforderlich (sehen sich unterhalten)]} Kontrastiert die Definition von Klassen in Java und Scala.

// Java: Öffentlichkeit Klasse Punkt {  Privatgelände Finale doppelt x, y;  Öffentlichkeit Punkt(Finale doppelt x, Finale doppelt y) {  Dies.x = x;  Dies.y = y;  }  Öffentlichkeit Punkt(  Finale doppelt x, Finale doppelt y,  Finale Boolesche Addtogrid  ) {  Dies(x, y);  wenn (Addtogrid)  Netz.Addtogrid(Dies);  }  Öffentlichkeit Punkt() {  Dies(0,0, 0,0);  }  Öffentlichkeit doppelt getx() {  Rückkehr x;  }  Öffentlichkeit doppelt Gety() {  Rückkehr y;  }  doppelt Entfernung(Finale Punkt Sonstiges) {  Rückkehr Entfernungsweiterpunkte(x, y,  Sonstiges.x, Sonstiges.y);  }  Privatgelände statisch Punkt Netz = Neu Punkt();  statisch doppelt Entfernungsweiterpunkte(  Finale doppelt x1, Finale doppelt y1,  Finale doppelt x2, Finale doppelt y2  ) {  Rückkehr Mathematik.Hypot(x1 - x2, y1 - y2);  } } 

// scala Klasse Punkt(  val x: Doppelt, val y: Doppelt,  Addtogrid: Boolesche = FALSCH ) {  importieren Punkt._  wenn (Addtogrid)  Netz.Addtogrid(Dies)  def Dies() = Dies(0,0, 0,0)  def Entfernung(Sonstiges: Punkt) =  Entfernungsweiterpunkte(x, y, Sonstiges.x, Sonstiges.y) } Objekt Punkt {  Privatgelände val Netz = Neu Punkt()  def Entfernungsweiterpunkte(x1: Doppelt, y1: Doppelt,  x2: Doppelt, y2: Doppelt) = {  Mathematik.Hypot(x1 - x2, y1 - y2)  } } 

Der obige Code zeigt einige der konzeptionellen Unterschiede zwischen Java und Scalas Umgang mit Klassen:

• Scala hat keine statischen Variablen oder Methoden. Stattdessen hat es Singleton -Objekte, die im Wesentlichen Klassen mit nur einer Instanz sind. Singleton -Objekte werden mit Verwendung deklariert Objekt Anstatt von Klasse. Es ist üblich, statische Variablen und Methoden in ein Singleton -Objekt mit demselben Namen wie dem Klassennamen zu platzieren, der dann als a bekannt ist Begleitobjekt.^[15] (Die zugrunde liegende Klasse für das Singleton -Objekt hat a $ angehängt. Daher für Klasse Foo mit Begleitobjekt Objekt foounter der Motorhaube gibt es eine Klasse Foo $ Mit dem Code des Begleitobjekts und einem Objekt dieser Klasse wird erstellt, wobei das verwendet wird Singleton -Muster.))
• Anstelle von Konstruktorparametern hat Scala Klassenparameter, die in der Klasse platziert sind, ähnlich wie Parameter zu einer Funktion. Wenn mit einem deklariert val oder var Modifikator, Felder werden ebenfalls mit demselben Namen definiert und automatisch aus den Klassenparametern initialisiert. (Unter der Haube geht der externe Zugriff auf öffentliche Felder immer durch den Accessor (Getter) und die Mutator (Setter), die automatisch erstellt werden. Die Accessor -Funktion hat den gleichen Namen wie das Feld, weshalb sie im obigen Beispiel nicht erforderlich ist Erklären Sie explizit Accessor -Methoden.) Beachten Sie, dass auch alternative Konstruktoren wie in Java deklariert werden können. Code, der in die gehen würde Standardkonstruktor (Außer der Initialisierung der Mitgliedsvariablen) geht direkt auf Klassenebene.
• Die Standardsicht der Sichtbarkeit in Scala ist Öffentlichkeit.

Merkmale (unter Bezugnahme auf Java)

Scala hat das gleiche Zusammenstellungsmodell wie Java und C#, nämlich separate Kompilien und Dynamische Klassenbelastung, damit dieser Scala -Code Java -Bibliotheken anrufen kann.

Die operativen Merkmale von Scala sind die gleichen wie die von Java. Der Scala Compiler generiert Byte -Code, der nahezu identisch mit dem vom Java -Compiler generierten.^[15] In der Tat kann der Scala -Code sein zerlegt zu lesbarem Java -Code mit Ausnahme bestimmter Konstruktoroperationen. Zum Java virtuelle Maschine (JVM), Scala -Code und Java -Code sind nicht zu unterscheiden. Der einzige Unterschied ist eine zusätzliche Laufzeitbibliothek. Scala-Bibliothek.Jar.^[30]

Scala fügt eine große Anzahl von Merkmalen im Vergleich zu Java hinzu und hat einige grundlegende Unterschiede in seinem zugrunde liegenden Modell für Ausdrücke und Typen, die die Sprache theoretisch sauberer machen und mehrere beseitigen Eckfälle in Java. Aus der Sicht der Scala ist dies praktisch wichtig, da auch in C#mehrere zusätzliche Funktionen in Scala erhältlich sind.

Syntaktische Flexibilität

Wie oben erwähnt, hat Scala im Vergleich zu Java eine Menge syntaktischer Flexibilität. Das Folgende sind einige Beispiele:

• Semikolone sind unnötig; Linien werden automatisch miteinander verbunden, wenn sie mit einem Token beginnen oder enden, das normalerweise nicht in dieser Position vorhanden ist, oder wenn es nicht abgelegene Klammern oder Klammern gibt.
• Jede Methode kann als Infixoperator verwendet werden, z. "%d apples" .format (num) und "%d Äpfel" Format num sind äquivalent. In der Tat mögen arithmetische Operatoren + und << werden wie alle anderen Methoden behandelt, da Funktionsnamen aus sequarigen Symbolen bestehen dürfen (mit wenigen Ausnahmen für Dinge wie Parens, Klammern und Zahnspangen, die speziell behandelt werden müssen); Die einzige besondere Behandlung, die solche Symbole-Methoden unterliegen, betrifft die Behandlung von Vorrang.
• Methoden anwenden und aktualisieren syntaktische Kurzformen haben. foo ()-wo Foo ist ein Wert (Singleton -Objekt oder Klasseninstanz) - ist kurz für foo.apply (), und foo () = 42 ist kurz für foo.update (42). Ähnlich, Foo (42) ist kurz für foo.apply (42), und foo (4) = 2 ist kurz für foo.update (4, 2). Dies wird für Sammelkurse verwendet und erstreckt sich auf viele andere Fälle, wie z. Stm Zellen.
• Scala unterscheidet zwischen No-Parens (def foo = 42) und leer-alens (def foo () = 42) Methoden. Wenn die Klammern eine leere PERS-Methode aufrufen, können die Klammern weggelassen werden, was nützlich ist, wenn Sie in Java-Bibliotheken aufrufen, die diese Unterscheidung nicht kennen, z. B. mit Verwendung foo.tostring Anstatt von foo.tostring (). Durch Konvent Nebenwirkungen.
• Methodennamen, die im Dickdarm enden (:) Erwarten Sie das Argument auf der linken Seite und den Empfänger auf der rechten Seite. Zum Beispiel die 4 :: 2 :: nil ist das gleiche wie Nil.::(2).::(4), die erste Form, die dem Ergebnis visuell entspricht (eine Liste mit dem ersten Element 4 und dem zweiten Element 2).
• Klassenkörpervariablen können transparent als separate Getter- und Setter -Methoden implementiert werden. Zum Merkmal Foolike {var bar Bar: int}Eine Implementierung kann sein object Foo extends FooLike { private var x = 0; def bar = x; def bar_=(value: Int) { x = value }} } }. Die Anrufseite kann weiterhin einen prägnanten verwenden foo.bar = 42.
• Die Verwendung von lockigen Zahnspangen anstelle von Klammern ist in Methodenaufrufen zulässig. Dies ermöglicht reine Bibliotheksimplementierungen neuer Steuerungsstrukturen.^[31] Zum Beispiel, zerbrechlich {... if (...) break () ...} Sieht so aus, als ob zerbrechlich war ein Sprach definierter Schlüsselwort, aber wirklich nur eine Methode, die eine aufnimmt Thunk Streit. Methoden, die Thunks oder Funktionen annehmen, platzieren diese häufig in einer zweiten Parameterliste, sodass die Syntax von Klammern und Curly Braces mischen kann: Vector.fill (4) {math.random} ist das gleiche wie Vector.Fill (4) (Math.Random). Die Variante der Curly -Zahnspangen ermöglicht es dem Ausdruck, mehrere Zeilen zu überspannen.
• For-Expressionen (weiter unten erklärt) können jeden Typ berücksichtigen, der monadische Methoden definiert wie z. Karte, Flatmap und Filter.

Für sich mögen diese als fragwürdige Entscheidungen erscheinen, aber gemeinsam dienen sie dem Zweck, zuzulassen Domänenspezifische Sprachen in Scala definiert werden, ohne den Compiler auszudehnen. Zum Beispiel, ErlangSondersyntax zum Senden einer Nachricht an einen Schauspieler, d.h. Schauspieler ! Botschaft Kann in einer Scala -Bibliothek ohne Sprachverlängerungen implementiert (und wird) in einer Scala -Bibliothek implementiert werden.

Einheitliches Typsystem

Java unterscheidet einen scharfen Unterschied zwischen primitiven Typen (z. int und Boolesche) und Referenztypen (alle Klasse). Nur Referenztypen sind Teil des Vererbungsschemas, die von abgeleitet werden java.lang.object. In Scala erben alle Typen aus einer Klasse der obersten Ebene Irgendein, deren unmittelbare Kinder sind Anyval (Werttypen wie z. Int und Boolesche) und Anyref (Referenztypen wie in Java). Dies bedeutet, dass die Java -Unterscheidung zwischen primitiven Typen und Boxtypen (z. int vs. Ganze Zahl) ist in Scala nicht vorhanden; Boxen und Unboxing ist für den Benutzer völlig transparent. Mit Scala 2.10 können neue Werttypen vom Benutzer definiert werden.

Forexpressionen

Anstelle der Java "für jeden"Loops zum Schleifen durch einen Iterator, Scala hat es zum-expressions, die ähnlich sind wie Listen Sie Verständnisse auf in Sprachen wie Haskell oder einer Kombination aus Listenverständnissen und Generatorausdrücke in Python. Forexpressionen mit dem Ertrag Schlüsselwort zulassen eines neuen Sammlung durch Iterieren über einen vorhandenen generiert werden und eine neue Sammlung desselben Typs zurückgeben. Sie werden vom Compiler in eine Reihe von übersetzt Karte, Flatmap und Filter Anrufe. Wo Ertrag wird nicht verwendet, der Code nähert sich einer Schleife im imperativen Stil, indem es übersetzt wird für jeden.

Ein einfaches Beispiel ist:

val s = zum (x <- 1 zu 25 wenn x*x > 50) Ertrag 2*x 

Das Ergebnis des Ausführens ist der folgende Vektor:

Vektor (16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50)

(Beachten Sie, dass der Ausdruck 1 bis 25 ist keine spezielle Syntax. Die Methode zu wird in der Standard -Scala -Bibliothek eher als Erweiterungsmethode für Ganzzahlen definiert, wobei eine Technik verwendet wird, die als implizite Konvertierungen bezeichnet wird^[32] Dadurch können neue Methoden zu vorhandenen Typen hinzugefügt werden.)

Ein komplexeres Beispiel für die Iterierung einer Karte ist:

// Bei einer Karte angegeben, in der Twitter -Benutzer angegeben, die in einer Reihe von Tweets erwähnt wurden, // und Häufigkeit, mit der jeder Benutzer erwähnt wurde, suchen Sie die Benutzer nach // In einer Karte bekannter Politiker und zurückgibt eine neue Karte, die nur die gibt // demokratische Politiker (als Objekte und nicht als Saiten). val Dem_mentions = zum {  (nennen, mal) <- Erwähnungen  Konto  <- Konten.erhalten(nennen)  wenn Konto.Party == "Demokratisch"  } Ertrag (Konto, mal) 

Ausdruck (Erwähnung, Zeiten) <- Erwähnungen ist ein Beispiel für Musteranpassung (siehe unten). Die Iterie über eine Karte gibt einen Satz Schlüsselwert zurück Tupelund Musteranpassungen ermöglicht es, dass die Tupel leicht in separate Variablen für den Schlüssel und den Wert zerlegt werden. In ähnlicher Weise gibt das Ergebnis des Verständnisses auch Schlüsselwert-Tupel zurück, die automatisch in eine Karte erstellt werden, da das Quellobjekt (aus der Variablen aus der Variablen Erwähnungen) ist eine Karte. Beachten Sie, dass wenn Erwähnungen Stattdessen hielt eine Liste, ein Set, ein Array oder eine andere Sammlung von Tupeln, genau der gleiche Code oben würde eine neue Sammlung desselben Typs ergeben.

Funktionelle Tendenzen

Während Scala alle in Java erhältlichen objektorientierten Funktionen unterstützt (und in der Tat auf verschiedene Weise), bietet er auch eine große Anzahl von Fähigkeiten, die normalerweise nur in gefunden werden, Funktionelle Programmierung Sprachen. Zusammen können diese Funktionen in diesen Funktionen in einem fast vollständig funktionalen Stil geschrieben werden und auch funktionale und objektorientierte Stile gemischt werden.

Beispiele sind:

• Keine Unterscheidung zwischen Aussagen und Ausdrücken
• Geben Sie Inferenz ein
• Anonyme Funktionen mit erfassender Semantik (d. H., Schließungen)
• Unveränderliche Variablen und Objekte
• Faule Bewertung
• Grabendauer Fortsetzungen (seit 2.8)
• Funktionen höherer Ordnung
• Verschachtelte Funktionen
• Currying
• Musteranpassung
• Algebraische Datentypen (durch Fallklassen)
• Tupel

Alles ist ein Ausdruck

Im Gegensatz zu C oder Java, aber ähnlich wie Sprachen wie z. Lispeln, Scala unterscheidet keinen Unterschied zwischen Aussagen und Ausdrücke. Alle Aussagen sind tatsächlich Ausdrücke, die auf einen gewissen Wert bewertet werden. Funktionen, die als Rückkehr deklariert werden würden Leere in C oder Java und Aussagen wie während das logischerweise keinen Wert zurückgibt, in Scala in Betracht gezogen wird, um den Typ zurückzugeben Einheit, die ein Singleton -Typ, mit nur einem Objekt dieser Art. Funktionen und Betreiber, die überhaupt nie zurückkehren (z. B. die Wurf Operator oder eine Funktion, die immer ausgeht nicht lokal Verwenden einer Ausnahme) logischerweise einen Rückgabetyp haben Nichts, ein spezieller Typ, der keine Objekte enthält; das ist ein Bodentyp, d.h. eine Unterklasse jedes möglichen Typs. (Dies macht wiederum den Typ Nichts kompatibel mit jedem Typ, zulässt Geben Sie Inferenz ein richtig funktionieren.)^[33]

Ebenso an If-then-else "Aussage" ist tatsächlich ein Ausdruck, der einen Wert erzeugt, d. H. Das Ergebnis der Bewertung einer der beiden Zweige. Dies bedeutet, dass ein solcher Codeblock überall eingefügt werden kann, wo ein Ausdruck gewünscht wird, was die Notwendigkeit eines ternärer Operator in Scala:

// Java: int Hexdigit = x > = 10 ? x + 'EIN' - 10 : x + '0'; 

// scala: val Hexdigit = wenn (x > = 10) x + 'EIN' - 10 anders x + '0' 

Aus ähnlichen Gründen, Rückkehr Aussagen sind in Scala unnötig und werden tatsächlich entmutigt. Wie in LISP ist der letzte Ausdruck in einem Codeblock der Wert dieses Codeblocks, und wenn der Codeblock der Körper einer Funktion ist, wird er von der Funktion zurückgegeben.

Um deutlich zu machen, dass alle Funktionen Ausdrücke sind, sogar Methoden, die zurückkehren Einheit werden mit einem Gleichen Zeichen geschrieben

def printvalue(x: Saite): Einheit = {  println("Ich habe ein %s gegessen".Format(x)) } 

oder äquivalent (mit Typinferenz und weglassen der unnötigen Klammern):

def printvalue(x: Saite) = println("Ich habe ein %s gegessen" Format x) 

Geben Sie Inferenz ein

Wegen Geben Sie Inferenz ein, Die Art der Variablen, Funktionsrückgabewerte und viele andere Ausdrücke können normalerweise weggelassen werden, wie der Compiler dies ableiten kann. Beispiele sind Val x = "foo" (für eine unveränderliche Konstante oder unveränderliches Objekt) oder var x = 1,5 (für eine Variable, deren Wert später geändert werden kann). Typ -Inferenz in Scala ist im Wesentlichen lokal, im Gegensatz zum globaleren Hindley-Milner Algorithmus verwendet in Haskell, Ml und andere rein funktionale Sprachen. Dies geschieht, um eine objektorientierte Programmierung zu erleichtern. Das Ergebnis ist, dass bestimmte Typen noch deklariert werden müssen (vor allem Funktionsparameter und die Rückgabetypen von rekursive Funktionen), z.B.

def Formatappel(x: Int) = "Ich habe %d Äpfel gegessen".Format(x) 

oder (mit einem Rückgabetyp für eine rekursive Funktion)

def Fakultät(x: Int): Int =  wenn (x == 0)  1  anders  x*Fakultät(x - 1) 

Anonyme Funktionen

In Scala sind Funktionen Objekte, und es gibt eine bequeme Syntax für die Angabe Anonyme Funktionen. Ein Beispiel ist der Ausdruck x => x <2, was eine Funktion mit einem Parameter angibt, der ihr Argument vergleicht, um festzustellen, ob sie weniger als 2 ist. Sie entspricht der Lisp -Form (Lambda (x) (<x 2)). Beachten Sie, dass weder die Art von x Der Rückgabetyp muss auch nicht explizit angegeben werden und können im Allgemeinen abgeleitet werden Geben Sie Inferenz ein; Sie können jedoch explizit angegeben werden, z. wie (x: int) => x <2 oder auch (x: int) => (x <2): boolean.

Anonyme Funktionen verhalten sich als wahr Schließungen Da sie automatisch alle Variablen erfassen, die in der Umgebung der beigefügten Funktion lexikalisch verfügbar sind. Diese Variablen sind auch nach der Rückgabe der Abschlussfunktion verfügbar und anders als bei Java's Anonyme innere Klassen Ich muss nicht als endgültig erklärt werden. (Es ist sogar möglich, solche Variablen zu ändern, wenn sie veränderlich sind, und der modifizierte Wert ist verfügbar, wenn die anonyme Funktion das nächste Mal aufgerufen wird.)

Eine noch kürzere Form der anonymen Funktion verwendet Platzhalter Variablen: Zum Beispiel Folgendes:

Listenkarte {x => SQRT (x)}

kann präziseer geschrieben werden als

LISTE MAP {SQRT (_)}

oder auch

Listen Sie Karte SQRT

Unveränderlichkeit

Scala erzwingt eine Unterscheidung zwischen unveränderlichen und veränderlichen Variablen. Veränderliche Variablen werden mit dem deklariert var Schlüsselwort und unveränderliche Werte werden mit dem deklariert val Stichwort. Eine Variable, die mit dem deklariert wurde val Schlüsselwort kann nicht auf die gleiche Weise neu zugewiesen werden, wie eine Variable mit dem deklariert wird Finale Schlüsselwort kann in Java nicht neu zugewiesen werden. vals sind nur flach unveränderlich, dh ein von einem Val verwiesener Objekt, auf das sich selbst nicht garantiert ist, ist unveränderlich.

Unveränderliche Klassen werden jedoch durch die Konvention gefördert, und die Scala Standard Library bietet eine Menge unveränderlicher Reihe Sammlung Klassen. Scala liefert veränderliche und unveränderliche Varianten der meisten Sammelklassen, und die unveränderliche Version wird immer verwendet, es sei denn, die veränderliche Version wird explizit importiert.^[34] Die unveränderlichen Varianten sind anhaltende Datenstrukturen Das gibt immer eine aktualisierte Kopie eines alten Objekts zurück, anstatt das alte Objekt zerstörerisch zu aktualisieren. Ein Beispiel dafür ist Unveränderliche verknüpfte Listen Wenn die Vorbereitung eines Elements auf eine Liste erfolgt, indem ein neuer Listenknoten zurückgegeben wird, der aus dem Element besteht, und einen Verweis auf den List -Schwanz. Das Anhängen eines Elements an eine Liste kann nur durchgeführt werden, indem alle Elemente in der alten Liste auf eine neue Liste nur mit dem neuen Element vorbereitet werden. Auf die gleiche Weise wird das Einfügen eines Elements in der Mitte einer Liste die erste Hälfte der Liste kopieren, aber einen Verweis auf die zweite Hälfte der Liste behalten. Dies wird als strukturelle Teilen bezeichnet. Dies ermöglicht eine sehr einfache Parallelität - es werden keine Schlösser benötigt, da niemals gemeinsame Objekte geändert werden.^[35]

Faule (nicht strenge) Bewertung

Die Bewertung ist streng streng ("eifrig"). Mit anderen Worten, Scala bewertet Ausdrücke, sobald sie verfügbar sind, und nicht nach Bedarf. Es ist jedoch möglich, eine variable Nicht-Strenge ("faul") mit dem zu deklarieren faul Schlüsselwort, was bedeutet, dass der Code zur Erzeugung des Wertes der Variablen erst dann bewertet wird, wenn die Variable zum ersten Mal verwiesen wird. Es gibt auch Nicht-Strengsammlungen verschiedener Typen (wie der Typ Strom, eine nicht streng verknüpfte Liste), und jede Sammlung kann mit dem nicht gestaltet werden Aussicht Methode. Nicht-Strengkollektionen bieten eine gute semantische Passform für serverproduzierte Daten, bei denen die Bewertung des Codes zum Generieren späterer Elemente einer Liste (die wiederum eine Anfrage an einen Server auslöst, der sich möglicherweise an einem anderen Ort im Web befindet) nur ausgelöst wird) passiert, wenn die Elemente tatsächlich benötigt werden.

Schwanzrekursion

Funktionelle Programmiersprachen liefern üblicherweise Schwanzanruf Optimierung, um eine umfassende Verwendung von zu ermöglichen Rekursion ohne Paketüberfluss Probleme. Einschränkungen im Java -Bytecode komplizieren die Schwanz -Anrufoptimierung auf dem JVM. Im Allgemeinen kann eine Funktion, die sich mit einem Schwanzaufruf aufruft, optimiert werden, aber gegenseitig rekursive Funktionen können dies nicht können. Trampoline wurden als Problemumgehung vorgeschlagen.^[36] Die Scala -Bibliothek wurde mit dem Objekt Trampolinunterstützung bereitgestellt scala.util.control.tailcalls Seit Scala 2.8.0 (veröffentlicht am 14. Juli 2010). Eine Funktion kann optional mit Anmerkungen mit Annotation mit @TailrecIn diesem Fall wird es nicht kompiliert, es sei denn, es ist schwanzrekursiv.^[37]

Fallklassen und Musteranpassung

Scala hat eingebaute Unterstützung für Musteranpassung, was als eine anspruchsvollere, erweiterbare Version von a angesehen werden kann Schaltanweisung, wo willkürliche Datentypen abgestimmt werden können (anstatt nur einfache Typen wie Ganzzahlen, Boolesche und Zeichenfolgen), einschließlich willkürlicher Verschachteln. Eine besondere Art von Klasse, die als a bekannt ist Fallklasse wird zur Verfügung gestellt, einschließlich automatischer Unterstützung für das Musteranpassung und kann zum Modellieren der verwendet werden Algebraische Datentypen Wird in vielen funktionalen Programmiersprachen verwendet. (Aus der Sicht von Scala ist eine Fallklasse einfach eine normale Klasse, für die der Compiler automatisch bestimmte Verhaltensweisen hinzufügt, die auch manuell bereitgestellt werden könnten, z. B. Definitionen von Methoden, Parameter während des Musteranpassung.)

Ein Beispiel für eine Definition der schnelle Sorte Der Algorithmus unter Verwendung von Musteranpassungen ist Folgendes:

def QSORT(aufführen: Aufführen[Int]): Aufführen[Int] = aufführen passen {  Fall Null => Null  Fall Drehzahl :: Schwanz =>  val (kleiner, sich ausruhen) = Schwanz.Trennwand(_ < Drehzahl)  QSORT(kleiner) ::: Drehzahl :: QSORT(sich ausruhen) } 

Die Idee hier ist, dass wir eine Liste in die Elemente unterteilt, die weniger als einen Drehpunkt und die Elemente nicht weniger, jeden Teil rekursiv sortieren und die Ergebnisse zusammen mit dem dazwischen liegenden Drehpunkt einfügen. Dies verwendet das gleiche Divide-and-Conquer Strategie von Zusammenführen, sortieren und andere schnelle Sortieralgorithmen.

Das passen Der Bediener wird verwendet, um das Muster -Matching auf dem in gespeicherten Objekt durchzuführen aufführen. Jeder Fall Der Ausdruck wird wiederum versucht, ob er übereinstimmt, und das erste Spiel bestimmt das Ergebnis. In diesem Fall, Null entspricht nur dem wörtlichen Objekt Null, aber Pivot :: Schwanz entspricht einer nicht leeren Liste und gleichzeitig Zerstörungen die Liste gemäß dem angegebenen Muster. In diesem Fall hat der zugehörige Code Zugriff auf eine lokale Variable benannt Drehzahl Halten Sie den Kopf der Liste und eine andere Variable Schwanz Halten Sie den Schwanz der Liste. Beachten Sie, dass diese Variablen schreibgeschützt sind und der Variablen semantisch sehr ähnlich sind Bindungen mit dem Lassen Betreiber in Lisp und Schema.

Die Musteranpassung erfolgt auch in lokalen variablen Deklarationen. In diesem Fall der Rückgabewert des Anrufs an Tail.Partition ist ein Tupel - In diesem Fall zwei Listen. (Tupel unterscheiden sich von anderen Arten von Containern, z. B. Listen, da sie immer eine feste Größe haben und die Elemente unterschiedliche Typen haben können das Tupel.

Die Form _ <Pivot ist eine Erklärung von a Anonyme Funktion mit einer Platzhaltervariablen; Siehe den Abschnitt oben über anonyme Funktionen.

Die Listenbetreiber :: (Das fügt ein Element zu Beginn einer Liste hinzu, ähnlich wie Nachteile in Lisp und Schema) und ::: (was zwei Listen zusammen anfasst, ähnlich wie anhängen In Lisp und Schema) erscheinen beide. Trotz der Erscheinungen gibt es an einem dieser Betreiber nichts "eingebaut". Wie oben angegeben, kann jede Symbole als Funktionsname dienen, und eine an ein Objekt angewendete Methode kann geschrieben werden. "Infix"-Style ohne Periode oder Klammern. Die obige Zeile oben wie geschrieben:

Qsort (kleiner) ::: pivot :: Qsort (Ruhe)

könnte auch so geschrieben werden:

QSORT (Rest) .: :( Pivot). :: :( Qsort (kleiner))

In mehr Standard-Methodennotation. (Methoden, die mit einem Dickdarm enden, sind rechts assoziativ und binden nach rechts an das Objekt.)

Teilfunktionen

Im obigen Muster-Matching-Beispiel der Körper des passen Bediener ist a Teilfunktion, was aus einer Reihe von besteht Fall Ausdrücke, mit dem ersten Matching -Ausdruck, ähnlich dem Körper von a Schaltanweisung. Teilfunktionen werden auch im Ausnahmebetrieb von a verwendet Versuchen Aussage:

Versuchen {  ... } Fang {  Fall NFE:Numberformatexception => { println(NFE); Aufführen(0) }  Fall _ => Null } 

Schließlich kann eine Teilfunktion allein verwendet werden, und das Ergebnis des Aufrufens ist gleichbedeutend mit a passen darüber. Zum Beispiel der vorherige Code für schnelle Sorte kann so geschrieben werden:

val QSORT: Aufführen[Int] => Aufführen[Int] = {  Fall Null => Null  Fall Drehzahl :: Schwanz =>  val (kleiner, sich ausruhen) = Schwanz.Trennwand(_ < Drehzahl)  QSORT(kleiner) ::: Drehzahl :: QSORT(sich ausruhen) } 

Hier eine schreibgeschützte Variable wird deklariert, dessen Typ eine Funktion von Listen von Ganzzahlen bis hin zu Listen von Ganzzahlen ist und sie an eine Teilfunktion binden. (Beachten Sie, dass der einzelne Parameter der Teilfunktion niemals explizit deklariert oder benannt wird.) Wir können diese Variable jedoch immer noch genau so aufrufen, als wäre es eine normale Funktion:

Scala> QSORT(Aufführen(6,2,5,9)) res32: Aufführen[Int] = Aufführen(2, 5, 6, 9) 

Objektorientierte Erweiterungen

Scala ist rein objektorientierte Sprache in dem Sinne, dass jeder Wert ein ist Objekt. Datentypen und Verhalten von Objekten werden von beschrieben von Klassen und Züge. Klassenabstraktionen werden von erweitert von Unterklasse und von einem flexiblen mischen-basierter Zusammensetzungsmechanismus, um die Probleme von zu vermeiden Mehrfacherbe.

Merkmale sind Scalas Ersatz für Java's Schnittstellen. Schnittstellen in Java -Versionen unter 8 sind stark eingeschränkt und können nur abstrakte Funktionserklärungen enthalten. Dies hat zu einer Kritik geführt, dass die Bereitstellung von Komfortmethoden in Schnittstellen umständlich ist (dieselben Methoden müssen in jeder Implementierung neu implementiert werden), und es ist unmöglich, eine veröffentlichte Schnittstelle auf rückwärtskompatible Weise zu erweitern. Eigenschaften sind ähnlich wie mischen Klassen, insofern sie fast die Macht einer regulären abstrakten Klasse haben, ohne dass nur Klassenparameter (Scalas Äquivalent zu Javas Konstruktorparametern)), da die Merkmale immer mit einer Klasse gemischt werden. Das super Der Bediener verhält sich speziell in Merkmalen, sodass Merkmale zusätzlich zur Vererbung unter Verwendung von Zusammensetzung verkettet werden können. Das folgende Beispiel ist ein einfaches Fenstersystem:

abstrakt Klasse Fenster {  // abstrakt  def zeichnen() } Klasse SimpleWindow erweitert Fenster {  def zeichnen() {  println("In SimpleWindow" ")  // zeichne ein einfaches Fenster  } } Merkmal Fensterdekoration erweitert Fenster { } Merkmal Horizontalscrollbardekoration erweitert Fensterdekoration {  // "Abstract Override" ist hier benötigt, damit "Super ()" funktioniert, weil der Elternteil funktioniert  // Funktion ist abstrakt. Wenn es konkret wäre, reichen regelmäßig "Override" aus.  abstrakt überschreiben def zeichnen() {  println("In HorizontalsCrollbardekoration")  super.zeichnen()  // Zeichne nun eine horizontale Bildlaufleiste  } } Merkmal VerticalScrollbardekoration erweitert Fensterdekoration {  abstrakt überschreiben def zeichnen() {  println("In VerticalScrollBardecoration")  super.zeichnen()  // Zeichne nun eine vertikale Bildlaufleiste  } } Merkmal TitelleDecoration erweitert Fensterdekoration {  abstrakt überschreiben def zeichnen() {  println("In der Titelkoration")  super.zeichnen()  // Zeichne nun die Titelleiste  } } 

Eine Variable kann so deklariert werden:

val Mywin = Neu SimpleWindow mit VerticalScrollbardekoration mit Horizontalscrollbardekoration mit TitelleDecoration 

Das Ergebnis der Anrufe mywin.draw () ist:

in TitelleDecoration in Horizontalscrollbardekoration in VerticalScrollbardekoration in SimpleWindow 

Mit anderen Worten, der Anruf zu zeichnen führte zuerst den Code in ausgeführt in TitelleDecoration (das letzte Merkmal gemischt), dann (durch die super() Anrufe) durch die anderen gemischten Merkmale zurückgeführt und schließlich zum Code in Fenster, Auch wenn keines der voneinander geerbten Eigenschaften. Dies ähnelt dem Dekorateurmuster, ist aber prägnanter und weniger fehleranfälliger, da es nicht explizit das übergeordnete Fenster, die explizit weiterleitenden Funktionen, deren Implementierung nicht geändert wird, oder sich auf die Initialisierung von Entitätsbeziehungen der Laufzeit ausdrücklich weiterleiten muss. In anderen Sprachen könnte ein ähnlicher Effekt bei der Kompilierung mit einer langen linearen Kette von erreicht werden Implementierung VererbungAber mit dem Nachteil im Vergleich zu Scala müsste eine lineare Vererbungskette für jede mögliche Kombination der Mischungsmischung deklariert werden.

Ausdruckstypsystem

Scala ist mit einem ausdrucksstarken statischen System ausgestattet, das hauptsächlich die sichere und kohärente Verwendung von Abstraktionen erzwingt. Das Typsystem ist jedoch nicht Klang.^[38] Insbesondere unterstützt das Typsystem:

• Klassen und abstrakte Typen als Objektmitglieder
• Strukturarten
• Pfadabhängige Typen
• Zusammengesetzte Typen
• Explizit getippte Selbstreferenzen
• Generische Klassen
• Polymorph Methoden
• Ober- und Untergrenze
• Varianz
• Anmerkung
• Ansichten

Scala ist in der Lage Abschlusstypen durch Verwendung. Dies macht die meisten statischen Deklarationen optional. Statische Typen müssen nicht explizit deklariert werden, es sei denn, ein Compiler -Fehler gibt die Notwendigkeit an. In der Praxis werden einige statische Typdeklarationen zur Klarheit der Code enthalten.

Typanreicherung

Eine gemeinsame Technik in Scala, bekannt als "bereichern meine Bibliothek"^[39] (ursprünglich bezeichnet "Pimp meine Bibliothek"Von Martin Odensky im Jahr 2006;^[32] Aufgrund ihrer negativen Konnotationen wurden Bedenken hinsichtlich dieser Phrasierung geäußert^[40] und Unreife^[41]), ermöglicht neue Methoden, als wären sie zu bestehenden Typen hinzugefügt. Dies ähnelt dem C# -Konzept von Verlängerungsmethoden Aber leistungsfähiger, da die Technik nicht auf das Hinzufügen von Methoden beschränkt ist und beispielsweise zur Implementierung neuer Schnittstellen verwendet werden kann. In Scala beinhaltet diese Technik die Erklärung eines implizite Konvertierung Von dem Typ "Empfangen" der Methode zu einem neuen Typ (normalerweise einer Klasse), die den ursprünglichen Typ wickelt und die zusätzliche Methode liefert. Wenn eine Methode für einen bestimmten Typ nicht gefunden werden kann, sucht der Compiler automatisch nach anwendbaren impliziten Conversions zu Typen, die die betreffende Methode bereitstellen.

Mit dieser Technik können neue Methoden zu einer vorhandenen Klasse mit einer Add-On-Bibliothek hinzugefügt werden Importe Die Add-On-Bibliothek erhält die neue Funktionalität und alle anderen Code sind nicht betroffen.

Das folgende Beispiel zeigt die Anreicherung des Typs Int mit Methoden Iseven und ist ungerade:

Objekt Myextensionen {  implizit Klasse Intprredicates(i: Int) {  def Iseven = i % 2 == 0  def ist ungerade  = !Iseven  } } importieren Myextensionen._  // Implizite Anreicherung in den Umfang bringen 4.Iseven  // -> wahr 

Importieren der Mitglieder von Myextensionen bringt die implizite Konvertierung in die Erweiterungsklasse mit Intprredicates in den Umfang.^[42]

Parallelität

Die Standardbibliothek von Scala beinhaltet Unterstützung für Futures und Versprechenzusätzlich zu den Standard -Java -Parallelitäts -APIs. Ursprünglich beinhaltete es auch Unterstützung für die Schauspielermodell, das jetzt als separate Open -Source -Plattform erhältlich ist Akka^[43] erstellt von Lightbend Inc. Akka -Schauspieler können es sein verteilt oder kombiniert mit Software -Transaktionsspeicher (Transaktoren). Alternative Kommunizieren von sequentiellen Prozessen (CSP) Implementierungen für kanalbasierte Nachrichtenübergabe kommunizieren Scala-Objekte,^[44] oder einfach über JCSP.

Ein Schauspieler ist wie eine Thread -Instanz mit einem Mailbox. Es kann durch erstellt werden von System.actorof, überschreiben die erhalten Methode zum Empfangen von Nachrichten und Verwendung der ! (Ausrufezeichen) Methode zum Senden einer Nachricht.^[45] Das folgende Beispiel zeigt einen EchoServer, der Nachrichten empfangen und dann drucken kann.

val Echoserver = Schauspieler(Neu Gesetz {  werden {  Fall Nachricht => println("Echo" + Nachricht)  } }) Echoserver ! "hallo" 

Scala bietet auch integrierte Unterstützung für datenparallele Programmierung in Form von parallele Sammlungen^[46] in seine Standardbibliothek seit Version 2.9.0 integriert.

Das folgende Beispiel zeigt, wie parallele Sammlungen verwendet werden, um die Leistung zu verbessern.^[47]

val URLs = Aufführen("https://scala-lang.org", "https://github.com/scala/scala") def Fromurl(URL: Saite) = Scala.io.Quelle.Fromurl(URL)  .Getlines().mkstring("\n") val t = System.CurrentTimemillis() URLs.Par.Karte(Fromurl(_)) // par gibt parallele Implementierung einer Sammlung zurück println("Zeit: " + (System.CurrentTimemillis - t) + "Frau") 

Neben Futures und Versprechen, Schauspielerunterstützung und Datenparallelität, Scala unterstützt auch asynchrone Programmierungen mit Software -Transaktionsspeicher und Ereignisströmen.^[48]

Cluster Computing

Die bekannteste Open-Source-Cluster-Komputierungslösung in Scala ist Apache Funken. Zusätzlich, Apache Kafka, das veröffentlichen - Subscribe Meldungswarteschlange Beliebt bei Spark und anderen Stream Processing -Technologien ist in Scala geschrieben.

Testen

Es gibt verschiedene Möglichkeiten, Code in Scala zu testen. Scalatest unterstützt mehrere Teststile und kann sich in Java-basierte Test-Frameworks integrieren.^[49] Scalacheck ist eine Bibliothek ähnlich wie Haskells Schneller Check.^[50] Specs2 ist eine Bibliothek zum Schreiben von ausführbaren Softwarespezifikationen.^[51] Scalamock bietet Unterstützung für das Testen hoher Ordnung und Curry-Funktionen.^[52] Jung und Testng sind beliebte Test -Frameworks in Java.

Versionen

Vergleich mit anderen JVM -Sprachen

Scala wird oft verglichen mit Groovig und Clojure, zwei weitere Programmiersprachen, die ebenfalls die JVM verwenden. In dem Typ-System gibt es wesentliche Unterschiede zwischen diesen Sprachen, in dem Ausmaß, in dem jede Sprache die objektorientierte und funktionale Programmierung und in der Ähnlichkeit ihrer Syntax mit der von Java unterstützt.

Scala ist statisch typisiert, während sowohl groovig als auch clojure sind dynamisch getippt. Dies macht das Typsystem komplexer und schwer zu verstehen, erlaubt aber fast alle^[38] Typfehler, die zur Kompilierungszeit erfasst werden sollen, und können zu einer erheblich schnelleren Ausführung führen. Im Gegensatz dazu erfordert die dynamische Typisierung mehr Tests, um die Programmkorrektheit der Programme zu gewährleisten, und ist daher im Allgemeinen langsamer, um eine größere Programmierflexibilität und Einfachheit zu ermöglichen. In Bezug auf Geschwindigkeitsunterschiede ermöglichen aktuelle Versionen von Groovy und Clojure optionale Typ -Anmerkungen, um Programmen zu helfen, den Overhead der dynamischen Typisierung zu vermeiden, wenn Typen praktisch statisch sind. Dieser Overhead wird weiter reduziert, wenn aktuelle Versionen des JVM verwendet werden, was mit einem verbessert wurde dynamisch aufrufen Anweisungen für Methoden, die mit dynamisch typisierten Argumenten definiert sind. Diese Fortschritte verringern die Geschwindigkeitslücke zwischen statischer und dynamischer Typisierung, obwohl eine statisch typisierte Sprache wie Scala immer noch die bevorzugte Wahl ist, wenn die Ausführungseffizienz sehr wichtig ist.

In Bezug auf Programmierparadigmen erbt Scala das objektorientierte Modell von Java und erweitert es auf verschiedene Weise. Groovy, aber auch stark objektorientiert, konzentriert sich eher auf die Verringerung der Ausführlichkeit. In Clojure wird die objektorientierte Programmierung nicht mit der funktionellen Programmierung als Hauptstärke der Sprache untersucht. Scala verfügt auch über viele funktionale Programmiermöglichkeiten, einschließlich Funktionen, die in erweiterten funktionalen Sprachen wie vorhanden sind Haskellund versucht, zwischen den beiden Paradigmen agnostisch zu sein, wodurch der Entwickler zwischen den beiden Paradigmen oder häufiger eine Kombination davon wählen kann.

In Bezug auf die Syntax -Ähnlichkeit mit Java erbt Scala einen Großteil von Javas Syntax, wie es bei Groovy der Fall ist. Clojure dagegen folgt dem Lispeln Syntax, die sowohl im Aussehen als auch in der Philosophie unterschiedlich ist. Das Lernen von Scala wird jedoch auch aufgrund seiner vielen fortgeschrittenen Merkmale als schwierig angesehen. Dies ist bei Groovy nicht der Fall, obwohl es sich auch um eine merkmalreiche Sprache handelt, hauptsächlich, weil es hauptsächlich eine Skriptsprache ist.

Annahme

Sprachrangliste

Ab 2022^{[aktualisieren]}, JVM-basierte Sprachen wie Clojure, Groovy, Kotlin, Scala sind hochrangig, aber immer noch deutlich weniger beliebt als die ursprüngliche Java-Sprache, die normalerweise an den drei besten Orten eingestuft wird.^[116][117]

Die Popularität des Programmiersprachenindex,^[118] Die Suche nach Sprach-Tutorials, der im April 2018 mit einem kleinen Abwärtstrend und dem 17. Januar 2021 den SCALA-15. Platz belegt hat Kotlin, Rang 12. Platz.

Das TIOBE index^[117] Popularität der Programmiersprache verwendet Internet-Suchmaschinenrankings und ähnliche Publikationsbeschaffung, um die Popularität der Sprache zu bestimmen. Ab September 2021^{[aktualisieren]}Es zeigt Scala am 31. Ort. In dieser Rangliste ist Scala voraus Haskell (38.) und Erlang, aber unten gehen (14.), Schnell (15.) und Perl (19.).

Die Redmonk -Programmiersprache Rankings, die Ranglisten basierend auf der Anzahl von festlegen GitHub Projekte und Fragen gestellt auf Paketüberfluss, Rang scala 14..^[116] Hier befindet sich Scala in einer zweiten Gruppe von Sprachen-durchaus von gehen, Power Shell, und Haskellund dahinter Schnell, Ziel c, Typoskript, und R.

In der Ausgabe 2018 der Zustand von Java Umfrage,^[119] Scala sammelte Daten von 5160 Entwicklern zu verschiedenen Java-bezogenen Themen und stellt den dritten Platz in Bezug auf die Verwendung alternativer Sprachen auf dem JVM. In Bezug auf die Ausgabe des Vorjahres der Umfrage fiel die Verwendung von Scala unter alternativen JVM -Sprachen von 28,4% auf 21,5%, die von Kotlin überholt wurden und von 11,4% im Jahr 2017 auf 28,8% im Jahr 2018 stiegen.

Bereits im Jahr 2013, als Scala in Version 2.10 war, die Gedankenwerke Technology Radar, ein Meinungsbasis -Bericht über eine Gruppe hochrangiger Technologen,^[120] Empfohlene Scala -Adoption in seiner Kategorie Sprachen und Frameworks.^[121] Im Juli 2014 wurde diese Einschätzung spezifischer und bezieht sich nun auf eine „Scala, die guten Teile“, die als „um erfolgreich Scala verwendet werden, müssen Sie die Sprache erforschen und eine sehr starke Meinung darüber haben, welche Teile richtig sind Für Sie erstellen Sie Ihre eigene Definition von Scala, den guten Teilen. “^[122]

Firmen

• Im April 2009, Twitter kündigte an, dass es große Teile seines Backends von ausgeschaltet hatte Rubin nach Scala und beabsichtigt, den Rest umzuwandeln.^[123]
• Vergoldet Verwendet Scala und Play Framework.^[124]
• Foursquare Verwendet Scala und Aufzug.^[125]
• Coursera Verwendet Scala und Play Framework.^[126]
• Apple Inc. Verwendet Scala in bestimmten Teams zusammen mit Java und dem Spielrahmen.^[127][128]
• Der Wächter High-Traffic-Website der Zeitung Guardian.co.uk^[129] Kündigte im April 2011 bekannt, dass es von Java nach Scala wechselte.^[130][131]
• Die New York Times enthüllt im Jahr 2014, dass sein internes Content -Management -System Blackbeard wird mit Scala, Akka und Spiel gebaut.^[132]
• Das Huffington Post Die Zeitung begann, Scala als Teil des Inhaltsablieferungssystems zu beschäftigen Athena im Jahr 2013.^[133]
• Schweizer Bank UBS Genehmigte Scala für den allgemeinen Produktionsgebrauch.^[134]
• LinkedIn verwendet die Scalatra Mikroframework seine Signal -API mit Strom versorgen.^[135]
• Treffen Verwendet das nicht filterte Toolkit für Echtzeit-APIs.^[136]
• Erinnere dich an die Milch Verwendet das nicht filterte Toolkit, Scala und Akka für öffentliche API- und Echtzeit-Updates.^[137]
• Verizon Ich versuche, "ein Framework der nächsten Generation" mit Scala zu machen.^[138]
• Airbnb Entwickelt Open-Source-Maschinenlernsoftware "Aerosolve", geschrieben in Java und Scala.^[139]
• Zalando Verschiebte seinen Technologiestapel von Java auf Scala und spielen.^[140]
• Soundcloud Verwendet Scala für sein Back-End, das Technologien wie Finagle (Micro Services) verwendet.^[141] Verbrennung und Funken (Datenverarbeitung).^[142]
• Datenbank verwendet Scala für die Apache Funken Big Data Platform.
• Morgan Stanley Verwendet Scala in ihren Finanz- und Asset-bezogenen Projekten ausgiebig.^[143]
• Es gibt Teams in ihnen Google und Alphabet Inc. diese verwenden Scala, hauptsächlich aufgrund von Akquisitionen wie z. Firebase^[144] und Nest.^[145]
• Walmart Kanada Verwendet Scala für ihre Back-End-Plattform.^[146]
• Duolingo Verwendet Scala für ihr Back-End-Modul, das Lektionen generiert.^[147]
• HMRC Verwendet Scala für viele Steueranträge für britische Regierung.^[148]
• M1 -Finanzierung Verwendet Scala für ihre Back-End-Plattform.^[149]

Kritik

Im März 2015, ehemaliger Vizepräsident der Plattform Engineering Group bei Twitter Raffi Krikorian, erklärte, er hätte Scala im Jahr 2011 wegen seiner nicht ausgewählt Lernkurve.^[150] Im selben Monat LinkedIn SVP Kevin Scott erklärte ihre Entscheidung, "ihre Abhängigkeit von Scala zu minimieren".^[151] Im November 2011, Jammern Aus Gründen, die die Lernkurve für neue Teammitglieder und die Inkompatibilität von einer Version des Scala -Compilers zum nächsten enthielten, von Scala weggezogen.^[152]

Siehe auch

• SBT, ein weit verbreitetes Build -Tool für Scala -Projekte
• Spielen!, ein Open-Source-Webanwendungs-Framework, das Scala unterstützt
• Akka, ein Open-Source-Toolkit zum Aufbau gleichzeitiger und verteilter Anwendungen
• Meißel, eine Open-Source-Sprache, die auf Scala basiert, die für Hardwaredesign und -generation verwendet wird.^[153]

Verweise

Weitere Lektüre