Scala LanguageErste Schritte mit Scala Language

Bemerkungen

Scala ist eine moderne Multi-Paradigma-Programmiersprache, die gängige Programmiermuster auf prägnante, elegante und typsichere Weise ausdrückt. Es integriert nahtlos Merkmale objektorientierter und funktionaler Sprachen.

Die meisten Beispiele erfordern eine funktionierende Scala-Installation. Dies ist die Scala-Installationsseite. Dies ist das Beispiel für das Einrichten von Scala . scalafiddle.net ist eine gute Ressource, um kleine Codebeispiele über das Web auszuführen.

Versionen

Ausführung Veröffentlichungsdatum
2.10.1 2013-03-13
2.10.2 2013-06-06
2.10.3 2013-10-01
2.10.4 2014-03-24
2.10.5 2015-03-05
2.10.6 2015-09-18
2.11.0 2014-04-21
2.11.1 2014-05-21
2.11.2 2014-07-24
2.11.4 2014-10-30
2.11.5 2014-01-14
2.11.6 2015-03-05
2.11.7 2015-06-23
2.11.8 2016-03-08
2.11.11 2017-04-19
2.12.0 2016-11-03
2.12.1 2016-12-06
2.12.2 2017-04-19

Hallo Welt durch Definieren einer "Hauptmethode"

Fügen Sie diesen Code in eine Datei mit dem Namen HelloWorld.scala :

object Hello {
  def main(args: Array[String]): Unit = {
    println("Hello World!")
  }
}

Live-Demo

So kompilieren Sie es in einen Bytecode, der von der JVM ausgeführt werden kann:

$ scalac HelloWorld.scala

Um es auszuführen:

$ scala Hello

Wenn die Scala-Laufzeit das Programm lädt, sucht es mit einer main nach einem Objekt namens Hello . Die main ist der Programmeintrittspunkt und wird ausgeführt.

Beachten Sie, dass Scala im Gegensatz zu Java keine Benennung von Objekten oder Klassen nach der Datei verlangt, in der sie enthalten sind. Stattdessen verweist der im Befehl scala Hello Parameter Hello auf das zu scala Hello Objekt, das die main Hauptmethode enthält. Es ist durchaus möglich, mehrere Objekte mit Hauptmethoden in derselben .scala Datei zu haben.

Das args Array enthält ggf. die Befehlszeilenargumente, die dem Programm übergeben werden. Zum Beispiel können wir das Programm folgendermaßen ändern:

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hello World!")
    for {
      arg <- args
    } println(s"Arg=$arg")
  }
}

Kompiliere es:

$ scalac HelloWorld.scala

Und dann führe es aus:

$ scala HelloWorld 1 2 3
Hello World!
Arg=1
Arg=2
Arg=3

Hallo Welt durch Erweiterung der App

object HelloWorld extends App {
  println("Hello, world!")
}

Live-Demo

Durch die Erweiterung der App Eigenschaft können Sie die Definition einer expliziten main vermeiden. Der gesamte Körper des HelloWorld Objekts wird als "Hauptmethode" behandelt.

2.11.0

Verzögerte Initialisierung

Laut der offiziellen Dokumentation verwendet App eine Funktion namens " Verzögerte Initialisierung" . Dies bedeutet, dass die Objektfelder nach dem Aufruf der Hauptmethode initialisiert werden.

2.11.0

Verzögerte Initialisierung

Laut der offiziellen Dokumentation verwendet App eine Funktion namens " Verzögerte Initialisierung" . Dies bedeutet, dass die Objektfelder nach dem Aufruf der Hauptmethode initialisiert werden.

DelayedInit ist jetzt für die allgemeine Verwendung veraltet , wird jedoch als Sonderfall für App weiterhin unterstützt . Der Support wird fortgesetzt, bis eine Ersatzfunktion festgelegt und implementiert ist.

Um auf Befehlszeilenargumente zuzugreifen, wenn Sie App , verwenden Sie this.args

object HelloWorld extends App {
  println("Hello World!")
  for {
    arg <- this.args
  } println(s"Arg=$arg")
}

Bei der Verwendung von App , wird der Körper des Objekts als die ausgeführt wird main gibt es keine Notwendigkeit , außer Kraft zu setzen main .

Hallo Welt als Drehbuch

Scala kann als Skriptsprache verwendet werden. Um dies zu demonstrieren, erstellen Sie HelloWorld.scala mit dem folgenden Inhalt:

println("Hello")

Führen Sie es mit dem Befehlszeileninterpreter aus (das $ ist die Befehlszeilenaufforderung):

$ scala HelloWorld.scala
Hello

Wenn Sie .scala auslassen (z. B. wenn Sie einfach scala HelloWorld .scala eingegeben haben), sucht der Läufer nach einer kompilierten .class Datei mit Bytecode, anstatt das Skript zu kompilieren und dann auszuführen.

Hinweis: Wenn Scala als Skriptsprache verwendet wird, kann kein Paket definiert werden.

In Betriebssystemen, die bash oder ähnliche Shell-Terminals verwenden, können Scala-Skripts unter Verwendung einer 'Shell-Präambel' ausgeführt werden. Erstellen Sie eine Datei mit dem Namen HelloWorld.sh und geben Sie Folgendes als Inhalt ein:

#!/bin/sh
exec scala "$0" "$@"
!#
println("Hello")

Die Teile zwischen #! und !# ist die 'Shell-Präambel' und wird als Bash-Skript interpretiert. Der Rest ist Scala.

Nachdem Sie die obige Datei gespeichert haben, müssen Sie ihr die Berechtigung "ausführbar" erteilen. In der Shell können Sie Folgendes tun:

$ chmod a+x HelloWorld.sh

(Beachten Sie, dass dies allen Benutzern die Berechtigung gibt: Lesen Sie mehr über chmod , um zu erfahren, wie Sie es für spezifischere Benutzergruppen festlegen.)

Jetzt können Sie das Skript folgendermaßen ausführen:

$ ./HelloWorld.sh

Verwenden der Scala REPL

Wenn Sie scala in einem Terminal ohne zusätzliche Parameter ausführen, wird ein REPL -Interpreter (Read-Eval-Print Loop) geöffnet:

nford:~ $ scala
Welcome to Scala 2.11.8 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_66).
Type in expressions for evaluation. Or try :help.

scala> 

Mit REPL können Sie Scala auf einem Arbeitsblatt ausführen: Der Ausführungskontext bleibt erhalten und Sie können Befehle manuell ausprobieren, ohne ein gesamtes Programm erstellen zu müssen. Wenn Sie beispielsweise val poem = "As halcyons we shall be" würde dies folgendermaßen aussehen:

scala> val poem = "As halcyons we shall be"
poem: String = As halcyons we shall be

Jetzt können wir unseren val drucken:

scala> print(poem)
As halcyons we shall be

Beachten Sie, dass val unveränderlich ist und nicht überschrieben werden kann:

scala> poem = "Brooding on the open sea"
<console>:12: error: reassignment to val
       poem = "Brooding on the open sea"

In der REPL können Sie jedoch einen val neu definieren (der zu einem Fehler in einem normalen Scala-Programm führen würde, wenn er im gleichen Umfang ausgeführt würde):

scala> val poem = "Brooding on the open sea"
poem: String = Brooding on the open sea

Für den Rest Ihrer REPL-Sitzung spiegelt diese neu definierte Variable die zuvor definierte Variable. REPLs sind hilfreich, um schnell zu sehen, wie Objekte oder anderer Code funktionieren. Alle Funktionen von Scala sind verfügbar: Sie können Funktionen, Klassen, Methoden usw. definieren.

Scala Quicksheet

Beschreibung Code
Weisen Sie einen unveränderlichen int-Wert zu val x = 3
Veränderlichen int-Wert zuweisen var x = 3
Weisen Sie einen unveränderlichen Wert mit explizitem Typ zu val x: Int = 27
Faul bewerteten Wert zuweisen lazy val y = print("Sleeping in.")
Binden Sie eine Funktion an einen Namen val f = (x: Int) => x * x
Binden Sie eine Funktion an einen Namen mit explizitem Typ val f: Int => Int = (x: Int) => x * x
Methode definieren def f(x: Int) = x * x
Definieren Sie eine Methode mit expliziter Typisierung def f(x: Int): Int = x * x
Definieren Sie eine Klasse class Hopper(someParam: Int) { ... }
Definieren Sie ein Objekt object Hopper(someParam: Int) { ... }
Definiere ein Merkmal trait Grace { ... }
Holen Sie sich das erste Element der Sequenz Seq(1,2,3).head
Wenn wechseln val result = if(x > 0) "Positive!"
Holen Sie sich alle Elemente der Sequenz außer zuerst Seq(1,2,3).tail
Eine Liste durchgehen for { x <- Seq(1,2,3) } print(x)
Verschachtelte Schleifen for {
x <- Seq(1,2,3)
y <- Seq(4,5,6)
} print(x + ":" + y)
Für jedes Listenelement die Funktion ausführen List(1,2,3).foreach { println }
Druck auf Standard aus print("Ada Lovelace")
Sortieren Sie eine Liste alphanumerisch List('b','c','a').sorted