Scala - Kurzanleitung
Scala, kurz für Scalable Language, ist eine hybride funktionale Programmiersprache. Es wurde von Martin Odersky erstellt. Scala integriert nahtlos die Funktionen objektorientierter und funktionaler Sprachen. Scala ist für die Ausführung auf der Java Virtual Machine kompiliert. Viele bestehende Unternehmen, die für geschäftskritische Anwendungen auf Java angewiesen sind, wenden sich an Scala, um ihre Entwicklungsproduktivität, Anwendungsskalierbarkeit und allgemeine Zuverlässigkeit zu steigern.
Hier haben wir einige Punkte vorgestellt, die Scala zur ersten Wahl für Anwendungsentwickler machen.
Scala ist objektorientiert
Scala ist eine reine objektorientierte Sprache in dem Sinne, dass jeder Wert ein Objekt ist. Typen und Verhalten von Objekten werden durch Klassen und Merkmale beschrieben, die in den folgenden Kapiteln erläutert werden.
Der Unterricht wird erweitert um subclassing und eine flexible mixin-based composition Mechanismus als sauberer Ersatz für Mehrfachvererbung.
Scala ist funktionsfähig
Scala ist auch eine funktionale Sprache in dem Sinne, dass jede Funktion ein Wert und jeder Wert ein Objekt ist, so dass letztendlich jede Funktion ein Objekt ist.
Scala bietet eine einfache Syntax zum Definieren anonymous functions, es unterstützt higher-order functionsermöglicht es Funktionen zu sein nestedund unterstützt currying. Diese Konzepte werden in den folgenden Kapiteln erläutert.
Scala ist statisch typisiert
Im Gegensatz zu einigen anderen statisch typisierten Sprachen (C, Pascal, Rust usw.) erwartet Scala nicht, dass Sie redundante Typinformationen bereitstellen. In den meisten Fällen müssen Sie keinen Typ angeben, und Sie müssen ihn auf keinen Fall wiederholen.
Scala läuft auf der JVM
Scala wird in Java-Bytecode kompiliert, der von der Java Virtual Machine (JVM) ausgeführt wird. Dies bedeutet, dass Scala und Java eine gemeinsame Laufzeitplattform haben. Sie können problemlos von Java nach Scala wechseln.
Der Scala-Compiler kompiliert Ihren Scala-Code in Java-Byte-Code, der dann vom 'scala' Befehl. Das 'scala'Befehl ist ähnlich dem java Befehl, indem es Ihren kompilierten Scala-Code ausführt.
Scala kann Java-Code ausführen
Mit Scala können Sie alle Klassen des Java SDK sowie Ihre eigenen benutzerdefinierten Java-Klassen oder Ihre bevorzugten Java Open Source-Projekte verwenden.
Scala kann Concurrent & Synchronize verarbeiten
Mit Scala können Sie allgemeine Programmiermuster effektiv ausdrücken. Es reduziert die Anzahl der Zeilen und hilft dem Programmierer, typsicher zu codieren. Sie können Codes unveränderlich schreiben, wodurch Parallelität und Parallelität (Synchronisieren) einfach angewendet werden können.
Scala gegen Java
Scala verfügt über eine Reihe von Funktionen, die sich vollständig von Java unterscheiden. Einige davon sind -
- Alle Typen sind Objekte
- Typinferenz
- Verschachtelte Funktionen
- Funktionen sind Objekte
- Unterstützung für domänenspezifische Sprache (DSL)
- Traits
- Closures
- Parallelitätsunterstützung inspiriert von Erlang
Scala Web Frameworks
Scala wird überall und vor allem in Webanwendungen für Unternehmen eingesetzt. Sie können einige der beliebtesten Scala-Webframeworks überprüfen -
Das Lift Framework
Das Play-Framework
Das Bowler-Framework
Scala kann auf jedem UNIX- oder Windows-basierten System installiert werden. Bevor Sie mit der Installation von Scala auf Ihrem Computer beginnen, muss Java 1.8 oder höher auf Ihrem Computer installiert sein.
Führen Sie die folgenden Schritte aus, um Scala zu installieren.
Schritt 1: Überprüfen Sie Ihre Java-Installation
Zunächst muss das Java Software Development Kit (SDK) auf Ihrem System installiert sein. Um dies zu überprüfen, führen Sie je nach Plattform, auf der Sie arbeiten, einen der beiden folgenden Befehle aus.
Wenn die Java-Installation ordnungsgemäß durchgeführt wurde, werden die aktuelle Version und die Spezifikation Ihrer Java-Installation angezeigt. Eine Beispielausgabe ist in der folgenden Tabelle angegeben.
Plattform | Befehl | Beispielausgabe |
---|---|---|
Windows | Öffnen Sie die Befehlskonsole und geben Sie - ein \>java –version |
Java-Version "1.8.0_31" Java (TM) SE-Laufzeit Umgebung (Build 1.8.0_31-b31) Java Hotspot (TM) 64-Bit-Server VM (Build 25.31-b07, gemischter Modus) |
Linux | Öffnen Sie das Befehlsterminal und geben Sie - ein $java –version |
Java-Version "1.8.0_31" Öffnen Sie die JDK-Laufzeitumgebung (rhel-2.8.10.4.el6_4-x86_64). Öffnen Sie die JDK 64-Bit-Server-VM (Build 25.31-b07, gemischter Modus). |
Wir gehen davon aus, dass auf den Lesern dieses Tutorials Java SDK Version 1.8.0_31 auf ihrem System installiert ist.
Falls Sie kein Java SDK haben, laden Sie die aktuelle Version von herunter http://www.oracle.com/technetwork/java/javase/downloads/index.html und installieren Sie es.
Schritt 2: Legen Sie Ihre Java-Umgebung fest
Stellen Sie die Umgebungsvariable JAVA_HOME so ein, dass sie auf den Speicherort des Basisverzeichnisses verweist, in dem Java auf Ihrem Computer installiert ist. Zum Beispiel,
Sr.Nr. | Plattform & Beschreibung |
---|---|
1 | Windows Setzen Sie JAVA_HOME auf C: \ ProgramFiles \ java \ jdk1.7.0_60 |
2 | Linux Exportieren Sie JAVA_HOME = / usr / local / java-current |
Hängen Sie den vollständigen Pfad des Java-Compiler-Speicherorts an den Systempfad an.
Sr.Nr. | Plattform & Beschreibung |
---|---|
1 | Windows Fügen Sie die Zeichenfolge "C: \ Programme \ Java \ jdk1.7.0_60 \ bin" an das Ende der Systemvariablen PATH an. |
2 | Linux Export PATH = $ PATH: $ JAVA_HOME / bin / |
Führen Sie den Befehl aus java -version an der Eingabeaufforderung wie oben erläutert.
Schritt 3: Installieren Sie Scala
Sie können Scala von herunterladen http://www.scala-lang.org/downloads. Zum Zeitpunkt des Schreibens dieses Tutorials habe ich 'scala-2.11.5-installer.jar' heruntergeladen. Stellen Sie sicher, dass Sie über Administratorrechte verfügen, um fortzufahren. Führen Sie nun den folgenden Befehl an der Eingabeaufforderung aus:
Plattform | Befehl & Ausgabe | Beschreibung |
---|---|---|
Windows | \> java –jar scala-2.11.5-installer.jar \> |
Dieser Befehl zeigt einen Installationsassistenten an, der Sie zur Installation von Scala auf Ihrem Windows-Computer führt. Während der Installation wird nach einer Lizenzvereinbarung gefragt. Akzeptieren Sie diese einfach und fragen Sie nach einem Pfad, in dem Scala installiert wird. Ich habe den Standardpfad "C: \ Programme \ Scala" ausgewählt. Sie können einen geeigneten Pfad nach Ihren Wünschen auswählen. |
Linux | Command - - $ java –jar scala-2.9.0.1-installer.jar Output - - Willkommen zur Installation von Scala 2.9.0.1! Die Homepage ist bei - http://Scala-lang.org/ Drücken Sie 1, um fortzufahren, 2, um zu beenden, 3, um erneut anzuzeigen 1 ................................................ [Beginn des Auspackens] [Verarbeitungspaket: Installation des Softwarepakets (1/1)] [Auspacken beendet] [Konsoleninstallation abgeschlossen] |
Während der Installation wird eine Lizenzvereinbarung angefordert, um Typ 1 zu akzeptieren, und es wird nach einem Pfad gefragt, in dem Scala installiert wird. Ich habe / usr / local / share eingegeben. Sie können einen geeigneten Pfad auswählen. |
Öffnen Sie abschließend eine neue Eingabeaufforderung und geben Sie ein Scala -versionund drücken Sie die Eingabetaste. Sie sollten Folgendes sehen -
Plattform | Befehl | Ausgabe |
---|---|---|
Windows | \> Scala-Version |
Scala Code Runner Version 2.11.5 - Copyright 2002-2013, LAMP / EPFL |
Linux | $ scala -version |
Scala Code Runner Version 2.9.0.1 - Copyright 2002-2013, LAMP / EPFL |
Wenn Sie ein gutes Verständnis für Java haben, ist es für Sie sehr einfach, Scala zu lernen. Der größte syntaktische Unterschied zwischen Scala und Java besteht darin, dass das ';' Das Zeilenendezeichen ist optional.
Wenn wir ein Scala-Programm betrachten, kann es als eine Sammlung von Objekten definiert werden, die über das Aufrufen der Methoden des jeweils anderen kommunizieren. Lassen Sie uns nun kurz untersuchen, was Klassen-, Objekt-, Methoden- und Instanzvariablen bedeuten.
Object- Objekte haben Zustände und Verhaltensweisen. Ein Objekt ist eine Instanz einer Klasse. Beispiel - Ein Hund hat Zustände - Farbe, Name, Rasse sowie Verhalten - wedeln, bellen und essen.
Class - Eine Klasse kann als Vorlage / Blaupause definiert werden, die die Verhaltensweisen / Zustände beschreibt, die sich auf die Klasse beziehen.
Methods- Eine Methode ist im Grunde ein Verhalten. Eine Klasse kann viele Methoden enthalten. Es ist in Methoden, in denen die Logik geschrieben, Daten manipuliert und alle Aktionen ausgeführt werden.
Fields- Jedes Objekt verfügt über einen eindeutigen Satz von Instanzvariablen, die als Felder bezeichnet werden. Der Status eines Objekts wird durch die diesen Feldern zugewiesenen Werte erstellt.
Closure - A. closure ist eine Funktion, deren Rückgabewert vom Wert einer oder mehrerer außerhalb dieser Funktion deklarierter Variablen abhängt.
Traits- Ein Merkmal kapselt Methoden- und Felddefinitionen, die dann durch Mischen in Klassen wiederverwendet werden können. Merkmale werden verwendet, um Objekttypen zu definieren, indem die Signatur der unterstützten Methoden angegeben wird.
Erstes Scala-Programm
Wir können ein Scala-Programm in zwei Modi ausführen: einer ist interactive mode und ein anderer ist script mode.
Interaktiver Modus
Öffnen Sie die Eingabeaufforderung und öffnen Sie Scala mit dem folgenden Befehl.
\>scala
Wenn Scala in Ihrem System installiert ist, wird die folgende Ausgabe angezeigt:
Welcome to Scala version 2.9.0.1
Type in expressions to have them evaluated.
Type :help for more information.
Geben Sie den folgenden Text rechts von der Scala-Eingabeaufforderung ein und drücken Sie die Eingabetaste -
scala> println("Hello, Scala!");
Es wird das folgende Ergebnis erzeugt -
Hello, Scala!
Skriptmodus
Verwenden Sie die folgenden Anweisungen, um ein Scala-Programm im Skriptmodus zu schreiben. Öffnen Sie den Editor und fügen Sie den folgenden Code hinzu.
Beispiel
object HelloWorld {
/* This is my first java program.
* This will print 'Hello World' as the output
*/
def main(args: Array[String]) {
println("Hello, world!") // prints Hello World
}
}
Speichern Sie die Datei als - HelloWorld.scala.
Öffnen Sie das Eingabeaufforderungsfenster und wechseln Sie in das Verzeichnis, in dem die Programmdatei gespeichert ist. Das 'scalacDer Befehl 'wird zum Kompilieren des Scala-Programms verwendet und generiert einige Klassendateien im aktuellen Verzeichnis. Einer von ihnen wird gerufenHelloWorld.class. Dies ist ein Bytecode, der auf Java Virtual Machine (JVM) mit 'ausgeführt wird.scala' Befehl.
Verwenden Sie den folgenden Befehl, um Ihr Scala-Programm zu kompilieren und auszuführen.
\> scalac HelloWorld.scala
\> scala HelloWorld
Ausgabe
Hello, World!
Grundlegende Syntax
Im Folgenden sind die grundlegenden Syntaxen und Codierungskonventionen in der Scala-Programmierung aufgeführt.
Case Sensitivity - Scala unterscheidet zwischen Groß- und Kleinschreibung, dh Kennung Hello und hello hätte in Scala eine andere Bedeutung.
Class Names- Bei allen Klassennamen sollte der erste Buchstabe in Großbuchstaben geschrieben sein. Wenn mehrere Wörter verwendet werden, um einen Namen für die Klasse zu bilden, sollte der erste Buchstabe jedes inneren Wortes in Großbuchstaben geschrieben sein.
Example - Klasse MyFirstScalaClass.
Method Names- Alle Methodennamen sollten mit einem Kleinbuchstaben beginnen. Wenn mehrere Wörter verwendet werden, um den Namen der Methode zu bilden, sollte der erste Buchstabe jedes inneren Wortes in Großbuchstaben geschrieben sein.
Example - def myMethodName ()
Program File Name- Der Name der Programmdatei sollte genau mit dem Objektnamen übereinstimmen. Wenn Sie die Datei speichern, sollten Sie sie unter dem Objektnamen speichern (bei Scala wird zwischen Groß- und Kleinschreibung unterschieden) und anhängen..scala'bis zum Ende des Namens. (Wenn der Dateiname und der Objektname nicht übereinstimmen, wird Ihr Programm nicht kompiliert.)
Example- Angenommen, 'HelloWorld' ist der Objektname. Dann sollte die Datei als 'HelloWorld.scala' gespeichert werden.
def main(args: Array[String]) - Die Verarbeitung des Scala-Programms beginnt mit der main () -Methode, die in jedem Scala-Programm obligatorisch ist.
Scala-Kennungen
Alle Scala-Komponenten erfordern Namen. Namen, die für Objekte, Klassen, Variablen und Methoden verwendet werden, werden als Bezeichner bezeichnet. Ein Schlüsselwort kann nicht als Bezeichner verwendet werden, und bei Bezeichnern wird zwischen Groß- und Kleinschreibung unterschieden. Scala unterstützt vier Arten von Bezeichnern.
Alphanumerische Bezeichner
Eine alphanumerische Kennung beginnt mit einem Buchstaben oder einem Unterstrich, auf den weitere Buchstaben, Ziffern oder Unterstriche folgen können. Das Zeichen '$' ist ein reserviertes Schlüsselwort in Scala und sollte nicht in Bezeichnern verwendet werden.
Folgende sind legal alphanumeric identifiers - -
age, salary, _value, __1_value
Folgende sind illegal identifiers - -
$salary, 123abc, -salary
Operator-IDs
Eine Operator-ID besteht aus einem oder mehreren Operatorzeichen. Operatorzeichen sind druckbare ASCII-Zeichen wie +,:,?, ~ Oder #.
Im Folgenden finden Sie rechtliche Betreiberkennungen -
+ ++ ::: <?> :>
Der Scala-Compiler "entwirrt" intern Operator-IDs, um sie in legale Java-IDs mit eingebetteten $ -Zeichen umzuwandeln. Zum Beispiel würde der Bezeichner: -> intern als dargestellt$colon$minus $ größer.
Gemischte Kennungen
Eine gemischte Kennung besteht aus einer alphanumerischen Kennung, gefolgt von einem Unterstrich und einer Operatorkennung.
Es folgen legale gemischte Kennungen -
unary_+, myvar_=
Hier definiert unary_ + als Methodenname einen unären + Operator und myvar_ = als Methodenname einen Zuweisungsoperator (Operatorüberladung).
Literale Bezeichner
Eine Literal-ID ist eine beliebige Zeichenfolge, die in Back-Ticks (`...`) eingeschlossen ist.
Es folgen rechtliche wörtliche Kennungen -
`x` `<clinit>` `yield`
Scala Schlüsselwörter
Die folgende Liste zeigt die reservierten Wörter in Scala. Diese reservierten Wörter dürfen nicht als Konstante, Variable oder andere Bezeichnernamen verwendet werden.
abstrakt | Fall | Fang | Klasse |
def | tun | sonst | erweitert |
falsch | Finale | schließlich | zum |
für einige | wenn | implizit | importieren |
faul | Spiel | Neu | Null |
Objekt | überschreiben | Paket | Privat |
geschützt | Rückkehr | versiegelt | Super |
diese | werfen | Merkmal | Versuchen |
wahr | Art | val | Var |
während | mit | Ausbeute | |
- - | :: | = | => |
<- | <: | <% | >: |
# | @ |
Kommentare in Scala
Scala unterstützt einzeilige und mehrzeilige Kommentare, die Java sehr ähnlich sind. Mehrzeilige Kommentare können verschachtelt sein, müssen jedoch ordnungsgemäß verschachtelt sein. Alle in einem Kommentar verfügbaren Zeichen werden vom Scala-Compiler ignoriert.
object HelloWorld {
/* This is my first java program.
* This will print 'Hello World' as the output
* This is an example of multi-line comments.
*/
def main(args: Array[String]) {
// Prints Hello World
// This is also an example of single line comment.
println("Hello, world!")
}
}
Leerzeilen und Leerzeichen
Eine Zeile, die nur Leerzeichen enthält, möglicherweise mit einem Kommentar, wird als Leerzeile bezeichnet, und Scala ignoriert sie vollständig. Token können durch Leerzeichen und / oder Kommentare getrennt werden.
Newline-Zeichen
Scala ist eine zeilenorientierte Sprache, in der Anweisungen durch Semikolons (;) oder Zeilenumbrüche abgeschlossen werden können. Ein Semikolon am Ende einer Anweisung ist normalerweise optional. Sie können eine eingeben, wenn Sie möchten, müssen dies jedoch nicht, wenn die Anweisung von selbst in einer einzelnen Zeile angezeigt wird. Andererseits ist ein Semikolon erforderlich, wenn Sie mehrere Anweisungen in eine einzelne Zeile schreiben. Die folgende Syntax enthält die Verwendung mehrerer Anweisungen.
val s = "hello"; println(s)
Scala-Pakete
Ein Paket ist ein benanntes Codemodul. Das Dienstprogramm Lift lautet beispielsweise net.liftweb.util. Die Paketdeklaration ist die erste Zeile ohne Kommentar in der Quelldatei wie folgt:
package com.liftcode.stuff
Scala-Pakete können importiert werden, damit im aktuellen Kompilierungsbereich auf sie verwiesen werden kann. Die folgende Anweisung importiert den Inhalt des scala.xml-Pakets -
import scala.xml._
Sie können eine einzelne Klasse und ein einzelnes Objekt, z. B. HashMap, aus dem Paket scala.collection.mutable importieren.
import scala.collection.mutable.HashMap
Sie können mehr als eine Klasse oder ein Objekt aus einem einzelnen Paket importieren, z. B. TreeMap und TreeSet aus dem Paket scala.collection.immutable.
import scala.collection.immutable.{TreeMap, TreeSet}
Dynamisch anwenden
Ein Markermerkmal, das dynamische Aufrufe ermöglicht. Instanzen x dieses Merkmals ermöglichen Methodenaufrufe x.meth (args) für beliebige Methodennamen meth und Argumentlistenargumente sowie Feldzugriffe x.field für beliebige Feldnamenfelder. Diese Funktion wird in Scala-2.10 eingeführt.
Wenn ein Aufruf von x nicht nativ unterstützt wird (dh wenn die Typprüfung fehlschlägt), wird er gemäß den folgenden Regeln neu geschrieben:
foo.method("blah") ~~> foo.applyDynamic("method")("blah")
foo.method(x = "blah") ~~> foo.applyDynamicNamed("method")(("x", "blah"))
foo.method(x = 1, 2) ~~> foo.applyDynamicNamed("method")(("x", 1), ("", 2))
foo.field ~~> foo.selectDynamic("field")
foo.varia = 10 ~~> foo.updateDynamic("varia")(10)
foo.arr(10) = 13 ~~> foo.selectDynamic("arr").update(10, 13)
foo.arr(10) ~~> foo.applyDynamic("arr")(10)
Scala hat dieselben Datentypen wie Java, denselben Speicherbedarf und dieselbe Genauigkeit. In der folgenden Tabelle finden Sie Details zu allen in Scala verfügbaren Datentypen.
Sr.Nr. | Datentyp & Beschreibung |
---|---|
1 | Byte 8-Bit-Wert mit Vorzeichen. Bereich von -128 bis 127 |
2 | Short 16 Bit vorzeichenbehafteter Wert. Bereich -32768 bis 32767 |
3 | Int 32-Bit-Wert mit Vorzeichen. Bereich -2147483648 bis 2147483647 |
4 | Long 64-Bit-Wert mit Vorzeichen. -9223372036854775808 bis 9223372036854775807 |
5 | Float 32-Bit-Float mit einfacher Genauigkeit nach IEEE 754 |
6 | Double 64-Bit-Float mit doppelter Genauigkeit nach IEEE 754 |
7 | Char 16-Bit-Unicode-Zeichen ohne Vorzeichen. Bereich von U + 0000 bis U + FFFF |
8 | String Eine Folge von Zeichen |
9 | Boolean Entweder das wörtliche wahr oder das wörtliche falsch |
10 | Unit Entspricht keinem Wert |
11 | Null Null oder leere Referenz |
12 | Nothing Der Subtyp jedes anderen Typs; enthält keine Werte |
13 | Any Der Supertyp eines beliebigen Typs; Jedes Objekt ist vom Typ Beliebig |
14 | AnyRef Der Supertyp eines beliebigen Referenztyps |
Alle oben aufgeführten Datentypen sind Objekte. Es gibt keine primitiven Typen wie in Java. Dies bedeutet, dass Sie Methoden auf einem Int, Long usw. aufrufen können.
Scala Basic Literals
Die Regeln, die Scala für Literale verwendet, sind einfach und intuitiv. In diesem Abschnitt werden alle grundlegenden Scala-Literale erläutert.
Integrale Literale
Ganzzahlige Literale sind normalerweise vom Typ Int oder vom Typ Long, wenn ein Suffix L oder l folgt. Hier sind einige ganzzahlige Literale -
0
035
21
0xFFFFFFFF
0777L
Gleitkomma-Literal
Gleitkomma-Literale sind vom Typ Float, gefolgt von einem Gleitkomma-Suffix F oder f, andernfalls vom Typ Double. Hier sind einige Gleitkomma-Literale -
0.0
1e30f
3.14159f
1.0e100
.1
Boolesche Literale
Die booleschen Literale true und false sind Mitglieder vom Typ Boolean.
Symbol Literale
Ein Symbolliteral 'x ist eine Abkürzung für den Ausdruck scala.Symbol("x"). Symbol ist eine Fallklasse, die wie folgt definiert ist.
package scala
final case class Symbol private (name: String) {
override def toString: String = "'" + name
}
Zeichenliterale
Ein Zeichenliteral ist ein einzelnes Zeichen in Anführungszeichen. Das Zeichen ist entweder ein druckbares Unicode-Zeichen oder wird durch eine Escape-Sequenz beschrieben. Hier sind einige Zeichenliterale -
'a'
'\u0041'
'\n'
'\t'
String-Literale
Ein String-Literal ist eine Folge von Zeichen in doppelten Anführungszeichen. Die Zeichen sind entweder druckbare Unicode-Zeichen oder werden durch Escape-Sequenzen beschrieben. Hier sind einige String-Literale -
"Hello,\nWorld!"
"This string contains a \" character."
Mehrzeilige Saiten
Ein mehrzeiliges Zeichenfolgenliteral ist eine Folge von Zeichen, die in dreifachen Anführungszeichen "" ... "" "eingeschlossen sind. Die Zeichenfolge ist willkürlich, außer dass sie nur ganz am Ende drei oder mehr aufeinanderfolgende Anführungszeichen enthalten darf.
Zeichen müssen nicht unbedingt druckbar sein. Zeilenumbrüche oder andere Steuerzeichen sind ebenfalls zulässig. Hier ist ein mehrzeiliges String-Literal -
"""the present string
spans three
lines."""
Nullwerte
Der Nullwert ist vom Typ scala.Nullund ist somit mit jedem Referenztyp kompatibel. Es bezeichnet einen Referenzwert, der sich auf ein spezielles "Null" -Objekt bezieht.
Escape-Sequenzen
Die folgenden Escape-Sequenzen werden in Zeichen- und Zeichenfolgenliteralen erkannt.
Escape-Sequenzen | Unicode | Beschreibung |
---|---|---|
\ b | \ u0008 | Rücktaste BS |
\ t | \ u0009 | horizontale Lasche HT |
\ n | \ u000c | Formfeed FF |
\ f | \ u000c | Formfeed FF |
\ r | \ u000d | Wagenrücklauf CR |
"" | \ u0022 | doppeltes Anführungszeichen " |
\ ' | \ u0027 | einfaches Anführungszeichen. |
\\ | \ u005c | Backslash \ |
Ein Zeichen mit einem Unicode zwischen 0 und 255 kann auch durch ein Oktal-Escape dargestellt werden, dh durch einen Backslash '\', gefolgt von einer Folge von bis zu drei Oktalzeichen. Das folgende Beispiel zeigt einige Escape-Zeichen -
Beispiel
object Test {
def main(args: Array[String]) {
println("Hello\tWorld\n\n" );
}
}
Wenn der obige Code kompiliert und ausgeführt wird, ergibt sich das folgende Ergebnis:
Ausgabe
Hello World
Variablen sind nichts anderes als reservierte Speicherplätze zum Speichern von Werten. Dies bedeutet, dass Sie beim Erstellen einer Variablen Speicherplatz im Speicher reservieren.
Basierend auf dem Datentyp einer Variablen weist der Compiler Speicher zu und entscheidet, was im reservierten Speicher gespeichert werden kann. Durch Zuweisen verschiedener Datentypen zu Variablen können Sie daher Ganzzahlen, Dezimalstellen oder Zeichen in diesen Variablen speichern.
Variable Aussage
Scala hat eine andere Syntax zum Deklarieren von Variablen. Sie können als Wert definiert werden, dh als Konstante oder als Variable. Hier wird myVar mit dem Schlüsselwort var deklariert. Es ist eine Variable, die den Wert ändern kann, und dies wird aufgerufenmutable variable. Im Folgenden finden Sie die Syntax zum Definieren einer Variablen mithilfe vonvar Schlüsselwort -
Syntax
var myVar : String = "Foo"
Hier wird myVal mit dem Schlüsselwort val deklariert. Dies bedeutet, dass es sich um eine Variable handelt, die nicht geändert werden kann, und die aufgerufen wirdimmutable variable. Im Folgenden finden Sie die Syntax zum Definieren einer Variablen mit dem Schlüsselwort val:
Syntax
val myVal : String = "Foo"
Variable Datentypen
Der Typ einer Variablen wird nach dem Variablennamen und vor dem Gleichheitszeichen angegeben. Sie können jeden Typ von Scala-Variablen definieren, indem Sie den Datentyp wie folgt angeben:
Syntax
val or val VariableName : DataType = [Initial Value]
Wenn Sie einer Variablen keinen Anfangswert zuweisen, gilt dieser wie folgt:
Syntax
var myVar :Int;
val myVal :String;
Variable Typinferenz
Wenn Sie einer Variablen einen Anfangswert zuweisen, kann der Scala-Compiler den Typ der Variablen anhand des ihr zugewiesenen Werts ermitteln. Dies wird als Inferenz vom Variablentyp bezeichnet. Daher können Sie diese Variablendeklarationen folgendermaßen schreiben:
Syntax
var myVar = 10;
val myVal = "Hello, Scala!";
Hier ist myVar standardmäßig vom Typ Int und myVal wird zur Variablen vom Typ String.
Mehrere Aufgaben
Scala unterstützt mehrere Aufgaben. Wenn ein Codeblock oder eine Methode ein Tupel zurückgibt (Tuple- Enthält eine Sammlung von Objekten unterschiedlichen Typs.) Das Tupel kann einer Val-Variablen zugewiesen werden. [Note - Wir werden Tupel in den folgenden Kapiteln studieren.]
Syntax
val (myVar1: Int, myVar2: String) = Pair(40, "Foo")
Und die Typinferenz macht es richtig -
Syntax
val (myVar1, myVar2) = Pair(40, "Foo")
Beispielprogramm
Das folgende Beispielprogramm erläutert den Prozess der Variablendeklaration in Scala. Dieses Programm deklariert vier Variablen - zwei Variablen werden mit Typdeklaration definiert und die restlichen zwei sind ohne Typdeklaration.
Beispiel
object Demo {
def main(args: Array[String]) {
var myVar :Int = 10;
val myVal :String = "Hello Scala with datatype declaration.";
var myVar1 = 20;
val myVal1 = "Hello Scala new without datatype declaration.";
println(myVar); println(myVal); println(myVar1);
println(myVal1);
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
10
Hello Scala with datatype declaration.
20
Hello Scala without datatype declaration.
Variabler Umfang
Variablen in Scala können je nach Verwendungsort drei verschiedene Bereiche haben. Sie können als Felder, als Methodenparameter und als lokale Variablen existieren. Nachfolgend finden Sie die Details zu den einzelnen Bereichstypen.
Felder
Felder sind Variablen, die zu einem Objekt gehören. Auf die Felder kann von jeder Methode im Objekt aus zugegriffen werden. Auf Felder kann auch außerhalb des Objekts zugegriffen werden, je nachdem, mit welchen Zugriffsmodifikatoren das Feld deklariert ist. Objektfelder können sowohl veränderbare als auch unveränderliche Typen sein und mit beiden definiert werdenvar oder val.
Methodenparameter
Methodenparameter sind Variablen, mit denen der Wert innerhalb einer Methode übergeben wird, wenn die Methode aufgerufen wird. Auf Methodenparameter kann nur innerhalb der Methode zugegriffen werden. Auf die übergebenen Objekte kann jedoch auch von außen zugegriffen werden, wenn Sie von außerhalb der Methode auf das Objekt verweisen. Methodenparameter sind immer unveränderlich, die durch definiert sindval Stichwort.
Lokale Variablen
Lokale Variablen sind Variablen, die innerhalb einer Methode deklariert sind. Auf lokale Variablen kann nur innerhalb der Methode zugegriffen werden. Die von Ihnen erstellten Objekte können jedoch der Methode entkommen, wenn Sie sie von der Methode zurückgeben. Lokale Variablen können sowohl veränderbare als auch unveränderliche Typen sein und mit beiden definiert werdenvar oder val.
In diesem Kapitel erfahren Sie, wie Sie Klassen und Objekte in der Scala-Programmierung verwenden. Eine Klasse ist eine Blaupause für Objekte. Sobald Sie eine Klasse definiert haben, können Sie mit dem Schlüsselwort Objekte aus dem Klassenplan erstellennew. Über das Objekt können Sie alle Funktionen der definierten Klasse nutzen.
Das folgende Diagramm zeigt die Klasse und das Objekt anhand eines Beispiels für einen Klassenschüler, das die Elementvariablen (Name und Rollennummer) und die Elementmethoden (setName () und setRollNo ()) enthält. Schließlich sind alle Mitglieder der Klasse. Klasse ist eine Blaupause und Objekte sind hier echt. In der folgenden Abbildung ist Student eine Klasse und Harini, John und Maria sind die Objekte der Student-Klasse. Diese haben Namen und Rollennummer.
Grundklasse
Es folgt eine einfache Syntax zum Definieren einer Basisklasse in Scala. Diese Klasse definiert zwei Variablenx und y und eine Methode: move, die keinen Wert zurückgibt. Klassenvariablen werden aufgerufen, Felder der Klasse und Methoden werden Klassenmethoden genannt.
Der Klassenname fungiert als Klassenkonstruktor, der eine Reihe von Parametern annehmen kann. Der obige Code definiert zwei Konstruktorargumente:xc und yc;; Sie sind beide im ganzen Körper der Klasse sichtbar.
Syntax
class Point(xc: Int, yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
Wie bereits in diesem Kapitel erwähnt, können Sie Objekte mit einem Schlüsselwort erstellen new und dann können Sie auf Klassenfelder und Methoden zugreifen, wie unten im Beispiel gezeigt -
Beispiel
import java.io._
class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
object Demo {
def main(args: Array[String]) {
val pt = new Point(10, 20);
// Move to a new location
pt.move(10, 10);
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Point x location : 20
Point y location : 30
Eine Klasse erweitern
Sie können eine Scala-Basisklasse erweitern und eine geerbte Klasse auf dieselbe Weise wie in Java entwerfen (verwenden) extends Schlüsselwort), aber es gibt zwei Einschränkungen: Das Überschreiben von Methoden erfordert die override Schlüsselwort und nur die primaryDer Konstruktor kann Parameter an den Basiskonstruktor übergeben. Lassen Sie uns unsere obige Klasse erweitern und eine weitere Klassenmethode hinzufügen.
Beispiel
Nehmen wir ein Beispiel für zwei Klassen. Point-Klasse (wie oben) und Location-Klasse ist eine geerbte Klasse mit dem Schlüsselwort extens. So ein 'extendsDie Klausel 'hat zwei Auswirkungen: Sie bewirkt, dass die Location-Klasse alle nicht privaten Mitglieder von der Point-Klasse erbt, und der Typ Location wird zu einem Subtyp des Typs Point- Klasse. Hier heißt also die Point-Klassesuperclassund die Klasse Location wird aufgerufensubclass. Das Erweitern einer Klasse und das Erben aller Funktionen einer übergeordneten Klasse wird aufgerufeninheritance Scala erlaubt jedoch die Vererbung nur von einer Klasse.
Note - Methoden move () Methode in Punktklasse und move() method in Location class Überschreiben Sie nicht die entsprechenden Definitionen von move, da es sich um unterschiedliche Definitionen handelt (z. B. verwenden die ersteren zwei Argumente, während die letzteren drei Argumente verwenden).
Versuchen Sie das folgende Beispielprogramm, um die Vererbung zu implementieren.
import java.io._
class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
class Location(override val xc: Int, override val yc: Int,
val zc :Int) extends Point(xc, yc){
var z: Int = zc
def move(dx: Int, dy: Int, dz: Int) {
x = x + dx
y = y + dy
z = z + dz
println ("Point x location : " + x);
println ("Point y location : " + y);
println ("Point z location : " + z);
}
}
object Demo {
def main(args: Array[String]) {
val loc = new Location(10, 20, 15);
// Move to a new location
loc.move(10, 10, 5);
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Point x location : 20
Point y location : 30
Point z location : 20
Implizite Klassen
Implizite Klassen ermöglichen implizite Konversationen mit dem primären Konstruktor der Klasse, wenn sich die Klasse im Gültigkeitsbereich befindet. Implizite Klasse ist eine Klasse, die mit dem Schlüsselwort 'implizit' gekennzeichnet ist. Diese Funktion wird in Scala 2.10 eingeführt.
Syntax- Das Folgende ist die Syntax für implizite Klassen. Hier befindet sich die implizite Klasse immer im Objektbereich, in dem alle Methodendefinitionen zulässig sind, da die implizite Klasse keine Klasse der obersten Ebene sein kann.
Syntax
object <object name> {
implicit class <class name>(<Variable>: Data type) {
def <method>(): Unit =
}
}
Beispiel
Nehmen wir ein Beispiel für eine implizite Klasse mit dem Namen IntTimesmit der Methode times (). Dies bedeutet, dass times () eine Schleifentransaktion enthält, die die angegebene Anweisung so oft ausführt, wie wir sie angeben. Nehmen wir an, die angegebene Anweisung lautet "4 mal println (" Hallo ")", was bedeutet, dass die println ("" Hallo ") - Anweisung 4 mal ausgeführt wird.
Das folgende ist das Programm für das gegebene Beispiel. In diesem Beispiel werden zwei Objektklassen verwendet (Ausführen und Demo), sodass diese beiden Klassen wie folgt in verschiedenen Dateien mit ihren jeweiligen Namen gespeichert werden müssen.
Run.scala - Speichern Sie das folgende Programm in Run.scala.
object Run {
implicit class IntTimes(x: Int) {
def times [A](f: =>A): Unit = {
def loop(current: Int): Unit =
if(current > 0){
f
loop(current - 1)
}
loop(x)
}
}
}
Demo.scala - Speichern Sie das folgende Programm in Demo.scala.
import Run._
object Demo {
def main(args: Array[String]) {
4 times println("hello")
}
}
Die folgenden Befehle werden zum Kompilieren und Ausführen dieser beiden Programme verwendet.
Befehl
\>scalac Run.scala
\>scalac Demo.scala
\>scala Demo
Ausgabe
Hello
Hello
Hello
Hello
Note - -
Implizite Klassen müssen in einer anderen Klasse / einem anderen Objekt / einer anderen Eigenschaft definiert werden (nicht in der obersten Ebene).
Implizite Klassen dürfen in ihrem Konstruktor nur ein nicht implizites Argument verwenden.
Implizite Klassen dürfen keine Methoden, Elemente oder Objekte im Gültigkeitsbereich sein, die denselben Namen wie die implizite Klasse haben.
Singleton-Objekte
Scala ist objektorientierter als Java, da wir in Scala keine statischen Mitglieder haben können. Stattdessen hat Scalasingleton objects. Ein Singleton ist eine Klasse, die nur eine Instanz haben kann, dh Object. Sie erstellen Singleton mit dem Schlüsselwortobjectanstelle des Klassenschlüsselworts. Da Sie ein Singleton-Objekt nicht instanziieren können, können Sie keine Parameter an den primären Konstruktor übergeben. Sie haben bereits alle Beispiele mit Singleton-Objekten gesehen, bei denen Sie die Hauptmethode von Scala aufgerufen haben.
Es folgt dasselbe Beispielprogramm zum Implementieren von Singleton.
Beispiel
import java.io._
class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
}
}
object Demo {
def main(args: Array[String]) {
val point = new Point(10, 20)
printPoint
def printPoint{
println ("Point x location : " + point.x);
println ("Point y location : " + point.y);
}
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Point x location : 10
Point y location : 20
Dieses Kapitel führt Sie durch die Scala-Zugriffsmodifikatoren. Mitglieder von Paketen, Klassen oder Objekten können mit den Zugriffsmodifikatoren privat und geschützt gekennzeichnet werden. Wenn wir keines dieser beiden Schlüsselwörter verwenden, wird der Zugriff als öffentlich angenommen. Diese Modifikatoren beschränken den Zugriff auf die Mitglieder auf bestimmte Codebereiche. Um einen Zugriffsmodifikator zu verwenden, fügen Sie sein Schlüsselwort in die Definition der Mitglieder eines Pakets, einer Klasse oder eines Objekts ein, wie im folgenden Abschnitt gezeigt wird.
Private Mitglieder
Ein privates Mitglied ist nur innerhalb der Klasse oder des Objekts sichtbar, das die Elementdefinition enthält.
Es folgt das Beispielcode-Snippet zur Erläuterung des privaten Mitglieds -
Beispiel
class Outer {
class Inner {
private def f() { println("f") }
class InnerMost {
f() // OK
}
}
(new Inner).f() // Error: f is not accessible
}
In Scala der Zugang (neues Inneres). f () ist illegal, da f in Inner als privat deklariert ist und der Zugriff nicht innerhalb der Klasse Inner erfolgt. Im Gegensatz dazu ist der erste Zugriff auf f in der Klasse Innermost in Ordnung, da dieser Zugriff im Hauptteil der Klasse Inner enthalten ist. Java würde beide Zugriffe zulassen, da eine äußere Klasse auf private Mitglieder ihrer inneren Klassen zugreifen kann.
Geschützte Mitglieder
Auf ein geschütztes Mitglied kann nur von Unterklassen der Klasse zugegriffen werden, in der das Mitglied definiert ist.
Im Folgenden finden Sie das Beispielcode-Snippet zur Erläuterung des geschützten Mitglieds:
Beispiel
package p {
class Super {
protected def f() { println("f") }
}
class Sub extends Super {
f()
}
class Other {
(new Super).f() // Error: f is not accessible
}
}
Der Zugriff auf f in der Klasse Sub ist in Ordnung, da f in der Klasse 'Super' als geschützt deklariert ist und die Klasse 'Sub' eine Unterklasse von Super ist. Im Gegensatz dazu ist der Zugriff auf f in der Klasse 'Other' nicht zulässig, da die Klasse 'Other' nicht von der Klasse 'Super' erbt. In Java wäre der letztere Zugriff weiterhin zulässig, da sich die Klasse 'Other' im selben Paket befindet wie die Klasse 'Sub'.
Öffentliche Mitglieder
Im Gegensatz zu privaten und geschützten Mitgliedern ist es nicht erforderlich, ein öffentliches Schlüsselwort für öffentliche Mitglieder anzugeben. Es gibt keinen expliziten Modifikator für öffentliche Mitglieder. Auf solche Mitglieder kann von überall aus zugegriffen werden.
Das folgende Beispiel-Code-Snippet erklärt das öffentliche Mitglied:
Beispiel
class Outer {
class Inner {
def f() { println("f") }
class InnerMost {
f() // OK
}
}
(new Inner).f() // OK because now f() is public
}
Schutzumfang
Zugriffsmodifikatoren in Scala können durch Qualifikationsmerkmale erweitert werden. Ein Modifikator der Form privat [X] oder geschützt [X] bedeutet, dass der Zugriff "bis" X privat oder geschützt ist, wobei X ein umschließendes Paket, eine Klasse oder ein Singleton-Objekt bezeichnet.
Betrachten Sie das folgende Beispiel -
Beispiel
package society {
package professional {
class Executive {
private[professional] var workDetails = null
private[society] var friends = null
private[this] var secrets = null
def help(another : Executive) {
println(another.workDetails)
println(another.secrets) //ERROR
}
}
}
}
Note - die folgenden Punkte aus dem obigen Beispiel -
Variable workDetails sind für jede Klasse innerhalb des beiliegenden Pakets professional zugänglich.
Variable Freunde sind für jede Klasse innerhalb der einschließenden Paketgesellschaft zugänglich.
Auf Variablengeheimnisse kann nur für das implizite Objekt innerhalb der Instanzmethoden zugegriffen werden (this).
Ein Operator ist ein Symbol, das den Compiler anweist, bestimmte mathematische oder logische Manipulationen durchzuführen. Scala ist reich an integrierten Operatoren und bietet die folgenden Arten von Operatoren:
- Rechenzeichen
- Vergleichsoperatoren
- Logische Operatoren
- Bitweise Operatoren
- Zuweisungsoperatoren
In diesem Kapitel werden die arithmetischen, relationalen, logischen, bitweisen, Zuweisungs- und anderen Operatoren nacheinander untersucht.
Rechenzeichen
Die folgenden arithmetischen Operatoren werden von der Scala-Sprache unterstützt. Nehmen wir zum Beispiel an, Variable A hält 10 und Variable B hält 20, dann -
Beispiele anzeigen
Operator | Beschreibung | Beispiel |
---|---|---|
+ | Fügt zwei Operanden hinzu | A + B ergibt 30 |
- - | Subtrahiert den zweiten Operanden vom ersten | A - B ergibt -10 |
* * | Multipliziert beide Operanden | A * B ergibt 200 |
/. | Teilt den Zähler durch den De-Zähler | B / A ergibt 2 |
%. | Der Moduloperator findet den Rest nach Division einer Zahl durch eine andere | B% A ergibt 0 |
Vergleichsoperatoren
Die folgenden Vergleichsoperatoren werden von der Scala-Sprache unterstützt. Nehmen wir zum Beispiel an, Variable A hält 10 und Variable B hält 20, dann -
Beispiele anzeigen
Operator | Beschreibung | Beispiel |
---|---|---|
== | Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn ja, wird die Bedingung wahr. | (A == B) ist nicht wahr. |
! = | Überprüft, ob die Werte von zwei Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr. | (A! = B) ist wahr. |
> | Überprüft, ob der Wert des linken Operanden größer als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A> B) ist nicht wahr. |
< | Überprüft, ob der Wert des linken Operanden kleiner als der Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A <B) ist wahr. |
> = | Überprüft, ob der Wert des linken Operanden größer oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A> = B) ist nicht wahr. |
<= | Überprüft, ob der Wert des linken Operanden kleiner oder gleich dem Wert des rechten Operanden ist. Wenn ja, wird die Bedingung wahr. | (A <= B) ist wahr. |
Logische Operatoren
Die folgenden logischen Operatoren werden von der Scala-Sprache unterstützt. Angenommen, Variable A hält 1 und Variable B hält 0, dann -
Beispiele anzeigen
Operator | Beschreibung | Beispiel |
---|---|---|
&& | Es heißt logischer UND-Operator. Wenn beide Operanden nicht Null sind, wird die Bedingung wahr. | (A && B) ist falsch. |
|| | Es heißt logischer ODER-Operator. Wenn einer der beiden Operanden nicht Null ist, wird die Bedingung wahr. | (A || B) ist wahr. |
! | Es heißt Logical NOT Operator. Verwenden Sie diese Option, um den logischen Status des Operanden umzukehren. Wenn eine Bedingung wahr ist, macht der Operator Logical NOT false. | ! (A && B) ist wahr. |
Bitweise Operatoren
Der bitweise Operator bearbeitet Bits und führt eine bitweise Operation durch. Die Wahrheitstabellen für &, | und ^ lauten wie folgt:
p | q | p & q | p | q | p ^ q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
Angenommen, A = 60; und B = 13; jetzt im Binärformat werden sie wie folgt sein -
A = 0011 1100
B = 0000 1101
-----------------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
Die von der Scala-Sprache unterstützten bitweisen Operatoren sind in der folgenden Tabelle aufgeführt. Angenommen, Variable A hält 60 und Variable B hält 13, dann -
Beispiele anzeigen
Operator | Beschreibung | Beispiel |
---|---|---|
& | Der binäre UND-Operator kopiert ein Bit in das Ergebnis, wenn es in beiden Operanden vorhanden ist. | (A & B) ergibt 12, was 0000 1100 ist |
| | Der binäre ODER-Operator kopiert ein Bit, wenn es in einem der Operanden vorhanden ist. | (A | B) ergibt 61, was 0011 1101 ist |
^ | Der binäre XOR-Operator kopiert das Bit, wenn es in einem Operanden gesetzt ist, aber nicht in beiden. | (A ^ B) ergibt 49, was 0011 0001 ist |
~ | Der Komplementoperator für binäre Einsen ist unär und bewirkt das Umdrehen von Bits. | (~ A) ergibt -61, was aufgrund einer vorzeichenbehafteten Binärzahl 1100 0011 in 2er-Komplementform ist. |
<< | Binärer Linksschaltoperator. Die Bitpositionen des Werts der linken Operanden werden um die vom rechten Operanden angegebene Anzahl von Bits nach links verschoben. | Ein << 2 ergibt 240, was 1111 0000 ist |
>> | Binärer Rechtsschieber. Die Bitpositionen des linken Operandenwerts werden um die vom rechten Operanden angegebene Anzahl von Bits nach rechts verschoben. | Eine >> 2 ergibt 15, was 1111 ist |
>>> | Verschieben Sie den Nullfüllungsoperator nach rechts. Der Wert der linken Operanden wird um die vom rechten Operanden angegebene Anzahl von Bits nach rechts verschoben, und verschobene Werte werden mit Nullen gefüllt. | Eine >>> 2 ergibt 15, was 0000 1111 ist |
Zuweisungsoperatoren
Es gibt folgende Zuweisungsoperatoren, die von der Scala-Sprache unterstützt werden:
Beispiele anzeigen
Operator | Beschreibung | Beispiel |
---|---|---|
= | Einfacher Zuweisungsoperator, Weist Werte von Operanden auf der rechten Seite dem Operanden auf der linken Seite zu | C = A + B weist C den Wert von A + B zu |
+ = | UND-Zuweisungsoperator hinzufügen. Er fügt dem linken Operanden den rechten Operanden hinzu und weist das Ergebnis dem linken Operanden zu | C + = A entspricht C = C + A. |
- = | Subtrahieren UND Zuweisungsoperator, subtrahiert den rechten Operanden vom linken Operanden und weist das Ergebnis dem linken Operanden zu | C - = A entspricht C = C - A. |
* = | Multiplizieren Sie den UND-Zuweisungsoperator. Er multipliziert den rechten Operanden mit dem linken Operanden und weist das Ergebnis dem linken Operanden zu | C * = A entspricht C = C * A. |
/ = | UND-Zuweisungsoperator teilen. Er teilt den linken Operanden mit dem rechten Operanden und weist das Ergebnis dem linken Operanden zu | C / = A entspricht C = C / A. |
% = | Modul- UND Zuweisungsoperator. Der Modul wird mit zwei Operanden verwendet und das Ergebnis dem linken Operanden zugewiesen | C% = A entspricht C = C% A. |
<< = | Linksverschiebung UND Zuweisungsoperator | C << = 2 ist dasselbe wie C = C << 2 |
>> = | Rechtsverschiebung UND Zuweisungsoperator | C >> = 2 ist dasselbe wie C = C >> 2 |
& = | Bitweiser UND-Zuweisungsoperator | C & = 2 ist dasselbe wie C = C & 2 |
^= | bitwise exclusive OR and assignment operator | C ^= 2 is same as C = C ^ 2 |
|= | bitwise inclusive OR and assignment operator | C |= 2 is same as C = C | 2 |
Vorrang der Betreiber in Scala
Die Operatorrangfolge bestimmt die Gruppierung von Begriffen in einem Ausdruck. Dies wirkt sich darauf aus, wie ein Ausdruck ausgewertet wird. Bestimmte Operatoren haben eine höhere Priorität als andere. Beispielsweise hat der Multiplikationsoperator eine höhere Priorität als der Additionsoperator -
Zum Beispiel ist x = 7 + 3 * 2; Hier wird x 13 zugewiesen, nicht 20, da der Operator * eine höhere Priorität als + hat. Daher wird er zuerst mit 3 * 2 multipliziert und dann zu 7 addiert.
Schauen Sie sich die folgende Tabelle an. Operatoren mit der höchsten Priorität werden oben in der Tabelle und Operatoren mit der niedrigsten Priorität unten angezeigt. Innerhalb eines Ausdrucks werden zuerst Operatoren mit höherer Priorität ausgewertet.
Kategorie | Operator | Assoziativität |
---|---|---|
Postfix | () [] | Links nach rechts |
Einstellig | ! ~ | Rechts nach links |
Multiplikativ | * /% | Links nach rechts |
Zusatzstoff | + - | Links nach rechts |
Verschiebung | >> >>> << | Links nach rechts |
Relational | >> = << = | Links nach rechts |
Gleichberechtigung | ==! = | Links nach rechts |
Bitweises UND | & | Links nach rechts |
Bitweises XOR | ^ | Links nach rechts |
Bitweises ODER | | | Links nach rechts |
Logisches UND | && | Links nach rechts |
Logisches ODER | || | Links nach rechts |
Zuordnung | = + = - = * = / =% = >> = << = & = ^ = | = | Rechts nach links |
Komma | , | Links nach rechts |
Dieses Kapitel führt Sie durch die bedingten Konstruktionsanweisungen in der Scala-Programmierung. Es folgt die allgemeine Form einer typischen IF ... ELSE-Struktur für die Entscheidungsfindung in den meisten Programmiersprachen.
Flussdiagramm
Das Folgende ist ein Flussdiagramm für die bedingte Anweisung.
if-Anweisung
Die 'if'-Anweisung besteht aus einem booleschen Ausdruck, gefolgt von einer oder mehreren Anweisungen.
Syntax
Die Syntax einer if-Anweisung lautet wie folgt.
if(Boolean_expression) {
// Statements will execute if the Boolean expression is true
}
Wenn der Boolesche Ausdruck true ergibt, wird der Codeblock im if-Ausdruck ausgeführt. Wenn nicht, wird der erste Codesatz nach dem Ende des 'if'-Ausdrucks (nach der schließenden geschweiften Klammer) ausgeführt.
Versuchen Sie das folgende Beispielprogramm, um bedingte Ausdrücke (wenn Ausdruck) in der Scala-Programmiersprache zu verstehen.
Beispiel
object Demo {
def main(args: Array[String]) {
var x = 10;
if( x < 20 ){
println("This is if statement");
}
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
This is if statement
If-else-Anweisung
Auf eine 'if'-Anweisung kann eine optionale else- Anweisung folgen , die ausgeführt wird, wenn der Boolesche Ausdruck false ist.
Syntax
Die Syntax eines if ... else lautet -
if(Boolean_expression){
//Executes when the Boolean expression is true
} else{
//Executes when the Boolean expression is false
}
Versuchen Sie das folgende Beispielprogramm, um bedingte Anweisungen (if-else-Anweisung) in der Scala-Programmiersprache zu verstehen.
Beispiel
object Demo {
def main(args: Array[String]) {
var x = 30;
if( x < 20 ){
println("This is if statement");
} else {
println("This is else statement");
}
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
This is else statement
If-else-if-else-Anweisung
Auf eine 'if'-Anweisung kann eine optionale' else if ... else' -Anweisung folgen , die sehr nützlich ist, um verschiedene Bedingungen mit einer einzelnen if ... else if-Anweisung zu testen.
Bei der Verwendung von if-, else if, else-Anweisungen sind nur wenige Punkte zu beachten.
Ein 'wenn' kann null oder eins haben und es muss nach jedem anderen wenn kommen.
Ein 'Wenn' kann null bis viele andere Wenn haben und sie müssen vor dem Anderen stehen.
Sobald ein anderer erfolgreich ist, wird keiner der verbleibenden anderen, wenn oder sonst, getestet.
Syntax
Das Folgende ist die Syntax eines 'if ... else if ... else' wie folgt:
if(Boolean_expression 1){
//Executes when the Boolean expression 1 is true
} else if(Boolean_expression 2){
//Executes when the Boolean expression 2 is true
} else if(Boolean_expression 3){
//Executes when the Boolean expression 3 is true
} else {
//Executes when the none of the above condition is true.
}
Versuchen Sie das folgende Beispielprogramm, um bedingte Anweisungen (if-else-if-else-Anweisung) in der Programmiersprache Scala zu verstehen.
Beispiel
object Demo {
def main(args: Array[String]) {
var x = 30;
if( x == 10 ){
println("Value of X is 10");
} else if( x == 20 ){
println("Value of X is 20");
} else if( x == 30 ){
println("Value of X is 30");
} else{
println("This is else statement");
}
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Value of X is 30
Verschachtelte if-else-Anweisung
Es ist immer legal zu nisten if-else Anweisungen, was bedeutet, dass Sie eine verwenden können if oder else-if Aussage in einem anderen if oder else-if Erklärung.
Syntax
Die Syntax für ein verschachteltes if-else lautet wie folgt:
if(Boolean_expression 1){
//Executes when the Boolean expression 1 is true
if(Boolean_expression 2){
//Executes when the Boolean expression 2 is true
}
}
Versuchen Sie das folgende Beispielprogramm, um bedingte Anweisungen (verschachtelte if-Anweisung) in der Programmiersprache Scala zu verstehen.
Beispiel
object Demo {
def main(args: Array[String]) {
var x = 30;
var y = 10;
if( x == 30 ){
if( y == 10 ){
println("X = 30 and Y = 10");
}
}
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
X = 30 and Y = 10
Dieses Kapitel führt Sie durch die Regelungsstrukturen in Scala-Programmiersprachen.
Es kann vorkommen, dass Sie einen Codeblock mehrmals ausführen müssen. Im Allgemeinen werden Anweisungen nacheinander ausgeführt: Die erste Anweisung in einer Funktion wird zuerst ausgeführt, gefolgt von der zweiten usw.
Programmiersprachen bieten verschiedene Steuerungsstrukturen, die kompliziertere Ausführungspfade ermöglichen.
Mit einer Schleifenanweisung können wir eine Anweisung oder eine Gruppe von Anweisungen mehrmals ausführen. Im Folgenden wird die allgemeine Form einer Schleifenanweisung in den meisten Programmiersprachen beschrieben:
Flussdiagramm
Die Programmiersprache Scala bietet die folgenden Arten von Schleifen, um die Schleifenanforderungen zu erfüllen. Klicken Sie auf die folgenden Links in der Tabelle, um deren Details zu überprüfen.
Sr.Nr. | Schleifentyp & Beschreibung |
---|---|
1 | while loop Wiederholt eine Anweisung oder eine Gruppe von Anweisungen, während eine bestimmte Bedingung erfüllt ist. Es testet die Bedingung, bevor der Schleifenkörper ausgeführt wird. |
2 | do-while loop Wie eine while-Anweisung, nur dass sie die Bedingung am Ende des Schleifenkörpers testet. |
3 | for loop Führt eine Folge von Anweisungen mehrmals aus und verkürzt den Code, der die Schleifenvariable verwaltet. |
Schleifensteuerungsanweisungen
Schleifensteueranweisungen ändern die Ausführung von ihrer normalen Reihenfolge. Wenn die Ausführung einen Bereich verlässt, werden alle automatischen Objekte, die in diesem Bereich erstellt wurden, zerstört. Als solches unterstützt Scala nichtbreak oder continueAnweisung wie Java, aber ab Scala Version 2.8 gibt es eine Möglichkeit, die Schleifen zu brechen. Klicken Sie auf die folgenden Links, um die Details zu überprüfen.
Sr.Nr. | Steueranweisung & Beschreibung |
---|---|
1 | break statement Beendet die loop Anweisung und überträgt die Ausführung an die Anweisung unmittelbar nach der Schleife. |
Die Endlosschleife
Eine Schleife wird zu einer Endlosschleife, wenn eine Bedingung niemals falsch wird. Wenn Sie Scala verwenden, wird diewhile Schleife ist der beste Weg, um eine Endlosschleife zu implementieren.
Das folgende Programm implementiert eine Endlosschleife.
Beispiel
object Demo {
def main(args: Array[String]) {
var a = 10;
// An infinite loop.
while( true ){
println( "Value of a: " + a );
}
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Wenn Sie den obigen Code ausführen, wird er in einer Endlosschleife ausgeführt, die Sie durch Drücken der Tasten Strg + C beenden können.
Value of a: 10
Value of a: 10
Value of a: 10
Value of a: 10
…………….
Eine Funktion ist eine Gruppe von Anweisungen, die eine Aufgabe ausführen. Sie können Ihren Code in separate Funktionen aufteilen. Wie Sie Ihren Code auf verschiedene Funktionen aufteilen, liegt bei Ihnen. Logischerweise erfolgt die Aufteilung normalerweise so, dass jede Funktion eine bestimmte Aufgabe ausführt.
Scala hat sowohl Funktionen als auch Methoden und wir verwenden die Begriffe Methode und Funktion mit einem kleinen Unterschied austauschbar. Eine Scala-Methode ist Teil einer Klasse, die einen Namen, eine Signatur, optional einige Anmerkungen und einen Bytecode enthält, wobei eine Funktion in Scala ein vollständiges Objekt ist, das einer Variablen zugewiesen werden kann. Mit anderen Worten, eine Funktion, die als Mitglied eines Objekts definiert ist, wird als Methode bezeichnet.
Eine Funktionsdefinition kann an einer beliebigen Stelle in einer Quelldatei angezeigt werden, und Scala ermöglicht verschachtelte Funktionsdefinitionen, dh Funktionsdefinitionen in anderen Funktionsdefinitionen. Der wichtigste zu beachtende Punkt ist, dass der Name der Scala-Funktion Zeichen wie +, ++, ~, &, -, -, \, /,: usw. enthalten kann.
Funktionserklärungen
Eine Scala-Funktionsdeklaration hat die folgende Form:
def functionName ([list of parameters]) : [return type]
Methoden werden implizit als abstrakt deklariert, wenn Sie das Gleichheitszeichen und den Methodenkörper nicht verwenden.
Funktionsdefinitionen
Eine Scala-Funktionsdefinition hat die folgende Form:
Syntax
def functionName ([list of parameters]) : [return type] = {
function body
return [expr]
}
Hier, return type kann ein beliebiger gültiger Scala-Datentyp sein und list of parameterswird eine Liste von Variablen sein, die durch Komma getrennt sind, und eine Liste von Parametern und Rückgabetypen sind optional. Sehr ähnlich zu Java, areturnDie Anweisung kann zusammen mit einem Ausdruck verwendet werden, falls die Funktion einen Wert zurückgibt. Es folgt die Funktion, die zwei Ganzzahlen addiert und deren Summe zurückgibt -
Syntax
object add {
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
}
Eine Funktion, die nichts zurückgibt, kann a zurückgeben Unit das ist gleichbedeutend mit voidin Java und zeigt an, dass die Funktion nichts zurückgibt. Die Funktionen, die in Scala nichts zurückgeben, werden Prozeduren genannt.
Syntax
Hier ist die Syntax -
object Hello{
def printMe( ) : Unit = {
println("Hello, Scala!")
}
}
Funktionen aufrufen
Scala bietet eine Reihe syntaktischer Variationen zum Aufrufen von Methoden. Das Folgende ist die Standardmethode zum Aufrufen einer Methode:
functionName( list of parameters )
Wenn eine Funktion mit einer Instanz des Objekts aufgerufen wird, verwenden wir die Java-ähnliche Punktnotation wie folgt:
[instance.]functionName( list of parameters )
Versuchen Sie das folgende Beispielprogramm, um dieselbe Funktion zu definieren und dann aufzurufen.
Beispiel
object Demo {
def main(args: Array[String]) {
println( "Returned Value : " + addInt(5,7) );
}
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Returned Value : 12
Scala-Funktionen sind das Herzstück der Scala-Programmierung. Deshalb wird Scala als funktionale Programmiersprache angenommen. Im Folgenden finden Sie einige wichtige Konzepte für Scala-Funktionen, die von einem Scala-Programmierer verstanden werden sollten.
Funktionen Call-by-Name | Funktionen mit benannten Argumenten |
Funktion mit variablen Argumenten | Rekursionsfunktionen |
Standardparameterwerte | Funktionen höherer Ordnung |
Verschachtelte Funktionen | Anonyme Funktionen |
Teilweise angewandte Funktionen | Currying-Funktionen |
EIN closure ist eine Funktion, deren Rückgabewert vom Wert einer oder mehrerer außerhalb dieser Funktion deklarierter Variablen abhängt.
Der folgende Code mit anonymer Funktion.
val multiplier = (i:Int) => i * 10
Hier ist die einzige im Funktionskörper verwendete Variable i * 10 i, die als Parameter für die Funktion definiert ist. Versuchen Sie den folgenden Code -
val multiplier = (i:Int) => i * factor
Es gibt zwei freie Variablen im Multiplikator: i und factor. Einer von ihnen, i, ist ein formaler Parameter für die Funktion. Daher wird es bei jedem Aufruf des Multiplikators an einen neuen Wert gebunden. Jedoch,factorist kein formaler Parameter, was ist das dann? Fügen wir noch eine Codezeile hinzu.
var factor = 3
val multiplier = (i:Int) => i * factor
Jetzt factorhat einen Verweis auf eine Variable außerhalb der Funktion, jedoch im umschließenden Bereich. Die Funktionsreferenzenfactorund liest jedes Mal seinen aktuellen Wert. Wenn eine Funktion keine externen Referenzen hat, wird sie trivial über sich selbst geschlossen. Es ist kein externer Kontext erforderlich.
Versuchen Sie das folgende Beispielprogramm.
Beispiel
object Demo {
def main(args: Array[String]) {
println( "multiplier(1) value = " + multiplier(1) )
println( "multiplier(2) value = " + multiplier(2) )
}
var factor = 3
val multiplier = (i:Int) => i * factor
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
multiplier(1) value = 3
multiplier(2) value = 6
Dieses Kapitel führt Sie durch die Scala-Saiten. In Scala wie in Java ist eine Zeichenfolge ein unveränderliches Objekt, dh ein Objekt, das nicht geändert werden kann. Andererseits werden Objekte, die wie Arrays geändert werden können, als veränderbare Objekte bezeichnet. Strings sind sehr nützliche Objekte. Im Rest dieses Abschnitts stellen wir wichtige Methoden von vorjava.lang.String Klasse.
String erstellen
Der folgende Code kann verwendet werden, um einen String zu erstellen -
var greeting = "Hello world!";
or
var greeting:String = "Hello world!";
Immer wenn der Compiler auf ein Zeichenfolgenliteral im Code stößt, erstellt er ein Zeichenfolgenobjekt mit dem Wert "Hallo Welt!". Das Schlüsselwort String kann auch in einer alternativen Deklaration angegeben werden, wie oben gezeigt.
Versuchen Sie das folgende Beispielprogramm.
Beispiel
object Demo {
val greeting: String = "Hello, world!"
def main(args: Array[String]) {
println( greeting )
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Hello, world!
Wie bereits erwähnt, ist die String-Klasse unveränderlich. Einmal erstelltes String-Objekt kann nicht geändert werden. Wenn viele Änderungen an Zeichenfolgen vorgenommen werden müssen, verwenden Sie die in Scala! Verfügbare String Builder-Klasse.
String-Länge
Methoden zum Abrufen von Informationen zu einem Objekt werden als Zugriffsmethoden bezeichnet. Eine Zugriffsmethode, die mit Zeichenfolgen verwendet werden kann, ist die length () -Methode, die die Anzahl der im Zeichenfolgenobjekt enthaltenen Zeichen zurückgibt.
Verwenden Sie das folgende Codesegment, um die Länge einer Zeichenfolge zu ermitteln:
Beispiel
object Demo {
def main(args: Array[String]) {
var palindrome = "Dot saw I was Tod";
var len = palindrome.length();
println( "String Length is : " + len );
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
String Length is : 17
Verketten von Strings
Die String-Klasse enthält eine Methode zum Verketten von zwei Strings -
string1.concat(string2);
Dies gibt eine neue Zeichenfolge zurück, die Zeichenfolge1 ist, und am Ende wird Zeichenfolge2 hinzugefügt. Sie können die concat () -Methode auch mit String-Literalen verwenden, wie in -
"My name is ".concat("Zara");
Zeichenfolgen werden häufiger mit dem Operator + verkettet, wie in -
"Hello," + " world" + "!"
Was zu -
"Hello, world!"
Die folgenden Codezeilen zum Ermitteln der Zeichenfolgenlänge.
Beispiel
object Demo {
def main(args: Array[String]) {
var str1 = "Dot saw I was ";
var str2 = "Tod";
println("Dot " + str1 + str2);
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Dot Dot saw I was Tod
Formatzeichenfolgen erstellen
Sie haben die Methoden printf () und format (), um Ausgaben mit formatierten Zahlen zu drucken. Die String-Klasse verfügt über eine äquivalente Klassenmethode, format (), die ein String-Objekt anstelle eines PrintStream-Objekts zurückgibt.
Probieren Sie das folgende Beispielprogramm aus, das die Methode printf () verwendet:
Beispiel
object Demo {
def main(args: Array[String]) {
var floatVar = 12.456
var intVar = 2000
var stringVar = "Hello, Scala!"
var fs = printf("The value of the float variable is " + "%f, while the value of the integer " + "variable is %d, and the string" + "is %s", floatVar, intVar, stringVar);
println(fs)
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
The value of the float variable is 12.456000,
while the value of the integer variable is 2000,
and the string is Hello, Scala!()
String-Interpolation
Die String-Interpolation ist die neue Methode zum Erstellen von Strings in der Programmiersprache Scala. Diese Funktion unterstützt die Versionen von Scala-2.10 und höher. String-Interpolation: Der Mechanismus zum direkten Einbetten von Variablenreferenzen in das Prozess-String-Literal.
Es gibt drei Arten (Interpolatoren) von Implementierungen in der String-Interpolation.
Der 's' String Interpolator
Das Literal 's' ermöglicht die Verwendung von Variablen direkt bei der Verarbeitung einer Zeichenfolge, wenn Sie 's' voranstellen. Jede String-Variable mit in einem Bereich, mit der in einem String verwendet werden kann. Das Folgende sind die verschiedenen Verwendungen des String-Interpolators von 's'.
Das folgende Beispielcode-Snippet für die Implementierung des Interpolators 's' beim Anhängen der String-Variablen ($ name) an einen normalen String (Hello) in der println-Anweisung.
val name = “James”
println(s “Hello, $name”) //output: Hello, James
String-Interpolater können auch beliebige Ausdrücke verarbeiten. Das folgende Codefragment zum Verarbeiten eines Strings (1 + 1) mit einem beliebigen Ausdruck ($ {1 + 1}) unter Verwendung des String-Interpolators 's'. Jeder beliebige Ausdruck kann in '$ {}' eingebettet werden.
println(s “1 + 1 = ${1 + 1}”) //output: 1 + 1 = 2
Probieren Sie das folgende Beispielprogramm zur Implementierung des Interpolators aus.
Beispiel
object Demo {
def main(args: Array[String]) {
val name = "James"
println(s"Hello, $name") println(s"1 + 1 = ${1 + 1}")
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Hello, James
1 + 1 = 2
Der 'f'-Interpolator
Der Literal-Interpolator 'f' ermöglicht das Erstellen eines formatierten Strings, ähnlich wie printf in der Sprache C. Bei Verwendung des Interpolators 'f' sollte auf alle Variablenreferenzen das von folgenprintf Stilformatbezeichner wie% d,% i,% f usw.
Nehmen wir ein Beispiel für das Anhängen eines Gleitkommawerts (Höhe = 1,9d) und einer Zeichenfolgenvariablen (Name = „James“) an eine normale Zeichenfolge. Der folgende Codeausschnitt zur Implementierung des Interpolators 'f'. Hier$name%s to print (String variable) James and $Höhe% 2.2f zum Drucken (Gleitkommawert) 1,90.
val height = 1.9d
val name = "James"
println(f"$name%s is $height%2.2f meters tall") //James is 1.90 meters tall
Es ist typsicher (dh) die Variablenreferenz und der folgende Formatbezeichner sollten übereinstimmen, andernfalls wird ein Fehler angezeigt. Der Interpolator 'f' verwendet die in Java verfügbaren Dienstprogramme zum Formatieren von Zeichenfolgen (Formatspezifizierer). Standardmäßig gibt es nach der Variablenreferenz kein% -Zeichen. Es wird als% s (String) angenommen.
'roher' Interpolator
Der 'rohe' Interpolator ähnelt dem 's'-Interpolator, außer dass er kein Entweichen von Literalen innerhalb einer Zeichenfolge ausführt. Die folgenden Codeausschnitte in einer Tabelle unterscheiden sich in der Verwendung von 's'- und' raw'-Interpolatoren. Bei Ausgaben von 's' Nutzung '\ n' Effekten als neue Zeile und bei Ausgabe von 'roher' Nutzung wirkt sich '\ n' nicht aus. Es wird die gesamte Zeichenfolge mit Escape-Buchstaben gedruckt.
Verwendung des Interpolators | 'rohe' Interpolatorverwendung |
---|---|
Program - - |
Program - - |
Output - - |
Output - - |
String-Methoden
Es folgt die Liste der von definierten Methoden java.lang.String Klasse und kann direkt in Ihren Scala-Programmen verwendet werden -
Sr.Nr. | Methoden mit Beschreibung |
---|---|
1 | char charAt(int index) Gibt das Zeichen am angegebenen Index zurück. |
2 | int compareTo(Object o) Vergleicht diesen String mit einem anderen Objekt. |
3 | int compareTo(String anotherString) Vergleicht zwei Zeichenfolgen lexikografisch. |
4 | int compareToIgnoreCase(String str) Vergleicht zwei Zeichenfolgen lexikografisch und ignoriert dabei Fallunterschiede. |
5 | String concat(String str) Verkettet die angegebene Zeichenfolge mit dem Ende dieser Zeichenfolge. |
6 | boolean contentEquals(StringBuffer sb) Gibt nur dann true zurück, wenn dieser String dieselbe Zeichenfolge wie der angegebene StringBuffer darstellt. |
7 | static String copyValueOf(char[] data) Gibt eine Zeichenfolge zurück, die die Zeichenfolge im angegebenen Array darstellt. |
8 | static String copyValueOf(char[] data, int offset, int count) Gibt eine Zeichenfolge zurück, die die Zeichenfolge im angegebenen Array darstellt. |
9 | boolean endsWith(String suffix) Testet, ob diese Zeichenfolge mit dem angegebenen Suffix endet. |
10 | boolean equals(Object anObject) Vergleicht diese Zeichenfolge mit dem angegebenen Objekt. |
11 | boolean equalsIgnoreCase(String anotherString) Vergleicht diesen String mit einem anderen String und ignoriert dabei die Überlegungen zur Groß- und Kleinschreibung. |
12 | byte getBytes() Codiert diesen String mit dem Standardzeichensatz der Plattform in eine Folge von Bytes und speichert das Ergebnis in einem neuen Byte-Array. |
13 | byte[] getBytes(String charsetName) Codiert diesen String mithilfe des benannten Zeichensatzes in eine Folge von Bytes und speichert das Ergebnis in einem neuen Byte-Array. |
14 | void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) Kopiert Zeichen aus dieser Zeichenfolge in das Zielzeichenarray. |
15 | int hashCode() Gibt einen Hash-Code für diese Zeichenfolge zurück. |
16 | int indexOf(int ch) Gibt den Index innerhalb dieser Zeichenfolge des ersten Vorkommens des angegebenen Zeichens zurück. |
17 | int indexOf(int ch, int fromIndex) Gibt den Index innerhalb dieser Zeichenfolge des ersten Vorkommens des angegebenen Zeichens zurück und startet die Suche am angegebenen Index. |
18 | int indexOf(String str) Gibt den Index innerhalb dieser Zeichenfolge des ersten Auftretens des angegebenen Teilstrings zurück. |
19 | int indexOf(String str, int fromIndex) Gibt den Index innerhalb dieser Zeichenfolge des ersten Auftretens des angegebenen Teilstrings zurück, beginnend mit dem angegebenen Index. |
20 | String intern() Gibt eine kanonische Darstellung für das Zeichenfolgenobjekt zurück. |
21 | int lastIndexOf(int ch) Gibt den Index innerhalb dieser Zeichenfolge des letzten Vorkommens des angegebenen Zeichens zurück. |
22 | int lastIndexOf(int ch, int fromIndex) Gibt den Index innerhalb dieser Zeichenfolge des letzten Vorkommens des angegebenen Zeichens zurück und sucht ab dem angegebenen Index rückwärts. |
23 | int lastIndexOf(String str) Gibt den Index innerhalb dieser Zeichenfolge des Auftretens der angegebenen Teilzeichenfolge ganz rechts zurück. |
24 | int lastIndexOf(String str, int fromIndex) Gibt den Index innerhalb dieser Zeichenfolge des letzten Vorkommens der angegebenen Teilzeichenfolge zurück und sucht ab dem angegebenen Index rückwärts. |
25 | int length() Gibt die Länge dieser Zeichenfolge zurück. |
26 | boolean matches(String regex) Gibt an, ob diese Zeichenfolge mit dem angegebenen regulären Ausdruck übereinstimmt. |
27 | boolean regionMatches(boolean ignoreCase, int toffset, String other, int offset, int len) Testet, ob zwei Zeichenfolgenbereiche gleich sind. |
28 | boolean regionMatches(int toffset, String other, int offset, int len) Testet, ob zwei Zeichenfolgenbereiche gleich sind. |
29 | String replace(char oldChar, char newChar) Gibt eine neue Zeichenfolge zurück, die sich aus dem Ersetzen aller Vorkommen von oldChar in dieser Zeichenfolge durch newChar ergibt. |
30 | String replaceAll(String regex, String replacement Ersetzt jeden Teilstring dieser Zeichenfolge, der dem angegebenen regulären Ausdruck entspricht, durch den angegebenen Ersatz. |
31 | String replaceFirst(String regex, String replacement) Ersetzt den ersten Teilstring dieser Zeichenfolge, der dem angegebenen regulären Ausdruck entspricht, durch den angegebenen Ersatz. |
32 | String[] split(String regex) Teilt diese Zeichenfolge um Übereinstimmungen des angegebenen regulären Ausdrucks. |
33 | String[] split(String regex, int limit) Teilt diese Zeichenfolge um Übereinstimmungen des angegebenen regulären Ausdrucks. |
34 | boolean startsWith(String prefix) Testet, ob diese Zeichenfolge mit dem angegebenen Präfix beginnt. |
35 | boolean startsWith(String prefix, int toffset) Testet, ob diese Zeichenfolge mit dem angegebenen Präfix beginnt, das mit einem angegebenen Index beginnt. |
36 | CharSequence subSequence(int beginIndex, int endIndex) Gibt eine neue Zeichenfolge zurück, die eine Teilsequenz dieser Folge ist. |
37 | String substring(int beginIndex) Gibt eine neue Zeichenfolge zurück, die eine Teilzeichenfolge dieser Zeichenfolge ist. |
38 | String substring(int beginIndex, int endIndex) Gibt eine neue Zeichenfolge zurück, die eine Teilzeichenfolge dieser Zeichenfolge ist. |
39 | char[] toCharArray() Konvertiert diese Zeichenfolge in ein neues Zeichenarray. |
40 | String toLowerCase() Konvertiert alle Zeichen in dieser Zeichenfolge nach den Regeln des Standardgebietsschemas in Kleinbuchstaben. |
41 | String toLowerCase(Locale locale) Konvertiert alle Zeichen in dieser Zeichenfolge nach den Regeln des angegebenen Gebietsschemas in Kleinbuchstaben. |
42 | String toString() Dieses Objekt (das bereits eine Zeichenfolge ist!) Wird selbst zurückgegeben. |
43 | String toUpperCase() Konvertiert alle Zeichen in dieser Zeichenfolge nach den Regeln des Standardgebietsschemas in Großbuchstaben. |
44 | String toUpperCase(Locale locale) Konvertiert alle Zeichen in dieser Zeichenfolge nach den Regeln des angegebenen Gebietsschemas in Großbuchstaben. |
45 | String trim() Gibt eine Kopie der Zeichenfolge zurück, wobei führende und nachfolgende Leerzeichen weggelassen werden. |
46 | static String valueOf(primitive data type x) Gibt die Zeichenfolgendarstellung des übergebenen Datentyparguments zurück. |
Scala bietet eine Datenstruktur, die array, in dem eine sequentielle Sammlung von Elementen desselben Typs mit fester Größe gespeichert wird. Ein Array wird zum Speichern einer Sammlung von Daten verwendet. Oft ist es jedoch sinnvoller, sich ein Array als eine Sammlung von Variablen desselben Typs vorzustellen.
Anstatt einzelne Variablen wie Nummer 0, Nummer 1, ... und Nummer 99 zu deklarieren, deklarieren Sie eine Array-Variable wie Zahlen und verwenden Zahlen [0], Zahlen [1] und ..., Zahlen [99] zur Darstellung einzelne Variablen. In diesem Lernprogramm wird erläutert, wie Sie Array-Variablen deklarieren, Arrays erstellen und Arrays mithilfe indizierter Variablen verarbeiten. Der Index des ersten Elements eines Arrays ist die Zahl Null und der Index des letzten Elements ist die Gesamtzahl der Elemente minus Eins.
Array-Variablen deklarieren
Um ein Array in einem Programm zu verwenden, müssen Sie eine Variable deklarieren, die auf das Array verweist, und Sie müssen den Array-Typ angeben, auf den die Variable verweisen kann.
Das Folgende ist die Syntax zum Deklarieren einer Array-Variablen.
Syntax
var z:Array[String] = new Array[String](3)
or
var z = new Array[String](3)
Hier wird z als Array von Strings deklariert, die bis zu drei Elemente enthalten können. Werte können einzelnen Elementen zugewiesen werden oder Zugriff auf einzelne Elemente erhalten. Dies kann mithilfe von Befehlen wie den folgenden erfolgen:
Befehl
z(0) = "Zara"; z(1) = "Nuha"; z(4/2) = "Ayan"
Hier zeigt das letzte Beispiel, dass der Index im Allgemeinen ein beliebiger Ausdruck sein kann, der eine ganze Zahl ergibt. Es gibt noch eine Möglichkeit, ein Array zu definieren:
var z = Array("Zara", "Nuha", "Ayan")
Das folgende Bild zeigt ein Array myList. Hier,myList enthält zehn Doppelwerte und die Indizes liegen zwischen 0 und 9.
Arrays verarbeiten
Bei der Verarbeitung von Array-Elementen verwenden wir häufig Schleifensteuerungsstrukturen, da alle Elemente in einem Array vom gleichen Typ sind und die Größe des Arrays bekannt ist.
Im Folgenden finden Sie ein Beispielprogramm zum Erstellen, Initialisieren und Verarbeiten von Arrays.
Beispiel
object Demo {
def main(args: Array[String]) {
var myList = Array(1.9, 2.9, 3.4, 3.5)
// Print all the array elements
for ( x <- myList ) {
println( x )
}
// Summing all elements
var total = 0.0;
for ( i <- 0 to (myList.length - 1)) {
total += myList(i);
}
println("Total is " + total);
// Finding the largest element
var max = myList(0);
for ( i <- 1 to (myList.length - 1) ) {
if (myList(i) > max) max = myList(i);
}
println("Max is " + max);
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5
Scala unterstützt verschiedene Array-Operationen nicht direkt und bietet verschiedene Methoden zum Verarbeiten von Arrays in jeder Dimension. Wenn Sie die verschiedenen Methoden verwenden möchten, ist der Import erforderlichArray._ Paket.
Mehrdimensionale Arrays
Es gibt viele Situationen, in denen Sie mehrdimensionale Arrays definieren und verwenden müssten (dh Arrays, deren Elemente Arrays sind). Beispielsweise sind Matrizen und Tabellen Beispiele für Strukturen, die als zweidimensionale Arrays realisiert werden können.
Das folgende Beispiel zeigt die Definition eines zweidimensionalen Arrays:
var myMatrix = ofDim[Int](3,3)
Dies ist ein Array mit drei Elementen, von denen jedes ein Array von Ganzzahlen mit drei Elementen ist.
Versuchen Sie das folgende Beispielprogramm, um ein mehrdimensionales Array zu verarbeiten:
Beispiel
import Array._
object Demo {
def main(args: Array[String]) {
var myMatrix = ofDim[Int](3,3)
// build a matrix
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
myMatrix(i)(j) = j;
}
}
// Print two dimensional array
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
print(" " + myMatrix(i)(j));
}
println();
}
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
0 1 2
0 1 2
0 1 2
Arrays verketten
Versuchen Sie das folgende Beispiel, in dem die concat () -Methode verwendet wird, um zwei Arrays zu verketten. Sie können mehr als ein Array als Argumente an die Methode concat () übergeben.
Beispiel
import Array._
object Demo {
def main(args: Array[String]) {
var myList1 = Array(1.9, 2.9, 3.4, 3.5)
var myList2 = Array(8.9, 7.9, 0.4, 1.5)
var myList3 = concat( myList1, myList2)
// Print all the array elements
for ( x <- myList3 ) {
println( x )
}
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5
Array mit Bereich erstellen
Verwendung der range () -Methode zum Generieren eines Arrays, das eine Folge ansteigender Ganzzahlen in einem bestimmten Bereich enthält. Sie können das letzte Argument als Schritt verwenden, um die Sequenz zu erstellen. Wenn Sie kein letztes Argument verwenden, wird der Schritt als 1 angenommen.
Let us take an example of creating an array of range (10, 20, 2): It means creating an array with elements between 10 and 20 and range difference 2. Elements in the array are 10, 12, 14, 16, and 18.
Another example: range (10, 20). Here range difference is not given so by default it assumes 1 element. It create an array with the elements in between 10 and 20 with range difference 1. Elements in the array are 10, 11, 12, 13, …, and 19.
The following example program shows how to create an array with ranges.
Example
import Array._
object Demo {
def main(args: Array[String]) {
var myList1 = range(10, 20, 2)
var myList2 = range(10,20)
// Print all the array elements
for ( x <- myList1 ) {
print( " " + x )
}
println()
for ( x <- myList2 ) {
print( " " + x )
}
}
}
Save the above program in Demo.scala. The following commands are used to compile and execute this program.
Command
\>scalac Demo.scala
\>scala Demo
Output
10 12 14 16 18
10 11 12 13 14 15 16 17 18 19
Scala Array Methods
Following are the important methods, which you can use while playing with array. As shown above, you would have to import Array._ package before using any of the mentioned methods. For a complete list of methods available, please check official documentation of Scala.
Sr.No | Methods with Description |
---|---|
1 | def apply( x: T, xs: T* ): Array[T] Creates an array of T objects, where T can be Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean. |
2 | def concat[T]( xss: Array[T]* ): Array[T] Concatenates all arrays into a single array. |
3 | def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit Copy one array to another. Equivalent to Java's System.arraycopy(src, srcPos, dest, destPos, length). |
4 | def empty[T]: Array[T] Returns an array of length 0 |
5 | def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T] Returns an array containing repeated applications of a function to a start value. |
6 | def fill[T]( n: Int )(elem: => T): Array[T] Returns an array that contains the results of some element computation a number of times. |
7 | def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]] Returns a two-dimensional array that contains the results of some element computation a number of times. |
8 | def iterate[T]( start: T, len: Int)( f: (T) => T ): Array[T] Returns an array containing repeated applications of a function to a start value. |
9 | def ofDim[T]( n1: Int ): Array[T] Creates array with given dimensions. |
10 | def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]] Creates a 2-dimensional array |
11 | def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]] Creates a 3-dimensional array |
12 | def range( start: Int, end: Int, step: Int ): Array[Int] Returns an array containing equally spaced values in some integer interval. |
13 | def range( start: Int, end: Int ): Array[Int] Returns an array containing a sequence of increasing integers in a range. |
14 | def tabulate[T]( n: Int )(f: (Int)=> T): Array[T] Returns an array containing values of a given function over a range of integer values starting from 0. |
15 | def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]] Returns a two-dimensional array containing values of a given function over ranges of integer values starting from 0. |
Scala has a rich set of collection library. Collections are containers of things. Those containers can be sequenced, linear sets of items like List, Tuple, Option, Map, etc. The collections may have an arbitrary number of elements or be bounded to zero or one element (e.g., Option).
Collections may be strict or lazy. Lazy collections have elements that may not consume memory until they are accessed, like Ranges. Additionally, collections may be mutable (the contents of the reference can change) or immutable (the thing that a reference refers to is never changed). Note that immutable collections may contain mutable items.
For some problems, mutable collections work better, and for others, immutable collections work better. When in doubt, it is better to start with an immutable collection and change it later if you need mutable ones.
This chapter throws light on the most commonly used collection types and most frequently used operations over those collections.
Sr.No | Collections with Description |
---|---|
1 | Scala Lists Scala's List[T] is a linked list of type T. |
2 | Scala Sets A set is a collection of pairwise different elements of the same type. |
3 | Scala Maps A Map is a collection of key/value pairs. Any value can be retrieved based on its key. |
4 | Scala Tuples Unlike an array or list, a tuple can hold objects with different types. |
5 | Scala Options Option[T] provides a container for zero or one element of a given type. |
6 | Scala Iterators An iterator is not a collection, but rather a way to access the elements of a collection one by one. |
A trait encapsulates method and field definitions, which can then be reused by mixing them into classes. Unlike class inheritance, in which each class must inherit from just one superclass, a class can mix in any number of traits.
Traits are used to define object types by specifying the signature of the supported methods. Scala also allows traits to be partially implemented but traits may not have constructor parameters.
A trait definition looks just like a class definition except that it uses the keyword trait. The following is the basic example syntax of trait.
Syntax
trait Equal {
def isEqual(x: Any): Boolean
def isNotEqual(x: Any): Boolean = !isEqual(x)
}
This trait consists of two methods isEqual and isNotEqual. Here, we have not given any implementation for isEqual where as another method has its implementation. Child classes extending a trait can give implementation for the un-implemented methods. So a trait is very similar to what we have abstract classes in Java.
Let us assume an example of trait Equal contain two methods isEqual() and isNotEqual(). The trait Equal contain one implemented method that is isEqual() so when user defined class Point extends the trait Equal, implementation to isEqual() method in Point class should be provided.
Here it is required to know two important method of Scala, which are used in the following example.
obj.isInstanceOf [Point] To check Type of obj and Point are same are not.
obj.asInstanceOf [Point] means exact casting by taking the object obj type and returns the same obj as Point type.
Try the following example program to implement traits.
Example
trait Equal {
def isEqual(x: Any): Boolean
def isNotEqual(x: Any): Boolean = !isEqual(x)
}
class Point(xc: Int, yc: Int) extends Equal {
var x: Int = xc
var y: Int = yc
def isEqual(obj: Any) = obj.isInstanceOf[Point] && obj.asInstanceOf[Point].x == y
}
object Demo {
def main(args: Array[String]) {
val p1 = new Point(2, 3)
val p2 = new Point(2, 4)
val p3 = new Point(3, 3)
println(p1.isNotEqual(p2))
println(p1.isNotEqual(p3))
println(p1.isNotEqual(2))
}
}
Save the above program in Demo.scala. The following commands are used to compile and execute this program.
Command
\>scalac Demo.scala
\>scala Demo
Output
true
false
true
Value classes and Universal Traits
Value classes are new mechanism in Scala to avoid allocating runtime objects. It contains a primary constructor with exactly one val parameter. It contains only methods (def) not allowed var, val, nested classes, traits, or objects. Value class cannot be extended by another class. This can be possible by extending your value class with AnyVal. The typesafety of custom datatypes without the runtime overhead.
Let us take an examples of value classes Weight, Height, Email, Age, etc. For all these examples it is not required to allocate memory in the application.
A value class not allowed to extend traits. To permit value classes to extend traits, universal traits are introduced which extends for Any.
Example
trait Printable extends Any {
def print(): Unit = println(this)
}
class Wrapper(val underlying: Int) extends AnyVal with Printable
object Demo {
def main(args: Array[String]) {
val w = new Wrapper(3)
w.print() // actually requires instantiating a Wrapper instance
}
}
Save the above program in Demo.scala. The following commands are used to compile and execute this program.
Command
\>scalac Demo.scala
\>scala Demo
Output
It will give you the hash code of Wrapper class.
Wrapper@13
When to Use Traits?
There is no firm rule, but here are few guidelines to consider −
If the behavior will not be reused, then make it a concrete class. It is not reusable behavior after all.
If it might be reused in multiple, unrelated classes, make it a trait. Only traits can be mixed into different parts of the class hierarchy.
If you want to inherit from it in Java code, use an abstract class.
If you plan to distribute it in compiled form, and you expect outside groups to write classes inheriting from it, you might lean towards using an abstract class.
If efficiency is very important, lean towards using a class.
Der Mustervergleich ist nach Funktionswerten und Schließungen das am zweithäufigsten verwendete Merkmal von Scala. Scala bietet eine hervorragende Unterstützung für den Mustervergleich bei der Verarbeitung der Nachrichten.
Eine Musterübereinstimmung enthält eine Folge von Alternativen, die jeweils mit dem Schlüsselwort beginnen case. Jede Alternative beinhaltet apattern und eine oder mehrere expressions, die ausgewertet wird, wenn das Muster übereinstimmt. Ein Pfeilsymbol => trennt das Muster von den Ausdrücken.
Probieren Sie das folgende Beispielprogramm aus, das zeigt, wie Sie mit einem ganzzahligen Wert übereinstimmen.
Beispiel
object Demo {
def main(args: Array[String]) {
println(matchTest(3))
}
def matchTest(x: Int): String = x match {
case 1 => "one"
case 2 => "two"
case _ => "many"
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
many
Der Block mit den case-Anweisungen definiert eine Funktion, die Ganzzahlen Zeichenfolgen zuordnet. Das Schlüsselwort match bietet eine bequeme Möglichkeit, eine Funktion (wie die obige Mustervergleichsfunktion) auf ein Objekt anzuwenden.
Probieren Sie das folgende Beispielprogramm aus, das einen Wert mit Mustern verschiedener Typen vergleicht.
Beispiel
object Demo {
def main(args: Array[String]) {
println(matchTest("two"))
println(matchTest("test"))
println(matchTest(1))
}
def matchTest(x: Any): Any = x match {
case 1 => "one"
case "two" => 2
case y: Int => "scala.Int"
case _ => "many"
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
2
many
one
Abgleich mit Fallklassen
Das case classessind spezielle Klassen, die beim Mustervergleich mit Fallausdrücken verwendet werden. Syntaktisch sind dies Standardklassen mit einem speziellen Modifikator:case.
Versuchen Sie Folgendes: Es handelt sich um ein einfaches Beispiel für den Mustervergleich mit der Fallklasse.
Beispiel
object Demo {
def main(args: Array[String]) {
val alice = new Person("Alice", 25)
val bob = new Person("Bob", 32)
val charlie = new Person("Charlie", 32)
for (person <- List(alice, bob, charlie)) {
person match {
case Person("Alice", 25) => println("Hi Alice!")
case Person("Bob", 32) => println("Hi Bob!")
case Person(name, age) => println(
"Age: " + age + " year, name: " + name + "?")
}
}
}
case class Person(name: String, age: Int)
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Hi Alice!
Hi Bob!
Age: 32 year, name: Charlie?
Durch Hinzufügen des case-Schlüsselworts fügt der Compiler automatisch eine Reihe nützlicher Funktionen hinzu. Das Schlüsselwort schlägt eine Zuordnung zu Fallausdrücken beim Mustervergleich vor.
Zunächst konvertiert der Compiler die Konstruktorargumente automatisch in unveränderliche Felder (vals). Das Schlüsselwort val ist optional. Wenn Sie veränderbare Felder möchten, verwenden Sie das Schlüsselwort var. Unsere Konstruktorargumentlisten sind jetzt kürzer.
Zweitens implementiert der Compiler automatisch equals, hashCode, und toStringMethoden für die Klasse, die die als Konstruktorargumente angegebenen Felder verwenden. Wir brauchen also keine eigenen toString () -Methoden mehr.
Schließlich auch der Körper von Person Klasse wird leer, weil es keine Methoden gibt, die wir definieren müssen!
In diesem Kapitel wird erläutert, wie Scala reguläre Ausdrücke unterstützt Regex Klasse im Paket scala.util.matching verfügbar.
Versuchen Sie das folgende Beispielprogramm, in dem wir versuchen, das Wort herauszufinden Scala aus einer Aussage.
Beispiel
import scala.util.matching.Regex
object Demo {
def main(args: Array[String]) {
val pattern = "Scala".r
val str = "Scala is Scalable and cool"
println(pattern findFirstIn str)
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Some(Scala)
Wir erstellen einen String und rufen den auf r( )Methode darauf. Scala konvertiert den String implizit in einen RichString und ruft diese Methode auf, um eine Instanz von Regex abzurufen. Um eine erste Übereinstimmung des regulären Ausdrucks zu finden, rufen Sie einfach die auffindFirstIn()Methode. Wenn wir nicht nur das erste Vorkommen finden möchten, sondern alle Vorkommen des übereinstimmenden Wortes finden möchten, können wir das verwendenfindAllIn( ) Methode und falls in der Zielzeichenfolge mehrere Scala-Wörter verfügbar sind, wird eine Sammlung aller übereinstimmenden Wörter zurückgegeben.
Sie können die Methode mkString () verwenden, um die resultierende Liste zu verketten, und Sie können eine Pipe (|) verwenden, um kleine und große Groß- und Kleinschreibung von Scala zu durchsuchen, und Sie können verwenden Regex Konstruktor statt oder r() Methode zum Erstellen eines Musters.
Versuchen Sie das folgende Beispielprogramm.
Beispiel
import scala.util.matching.Regex
object Demo {
def main(args: Array[String]) {
val pattern = new Regex("(S|s)cala")
val str = "Scala is scalable and cool"
println((pattern findAllIn str).mkString(","))
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Scala,scala
Wenn Sie passenden Text ersetzen möchten, können wir verwenden replaceFirstIn( ) das erste Spiel zu ersetzen oder replaceAllIn( ) alle Vorkommen zu ersetzen.
Beispiel
object Demo {
def main(args: Array[String]) {
val pattern = "(S|s)cala".r
val str = "Scala is scalable and cool"
println(pattern replaceFirstIn(str, "Java"))
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Java is scalable and cool
Reguläre Ausdrücke bilden
Scala erbt seine Syntax für reguläre Ausdrücke von Java, das wiederum die meisten Funktionen von Perl erbt. Hier sind nur einige Beispiele, die als Auffrischung ausreichen sollten -
In der folgenden Tabelle sind alle in Java verfügbaren Metazeichen-Syntax für reguläre Ausdrücke aufgeführt.
Unterausdruck | Streichhölzer |
---|---|
^ | Entspricht dem Zeilenanfang. |
$ | Entspricht dem Zeilenende. |
. | Entspricht einem einzelnen Zeichen außer Zeilenumbruch. Mit der Option m kann auch der Zeilenumbruch abgeglichen werden. |
[...] | Entspricht einem einzelnen Zeichen in Klammern. |
[^ ...] | Entspricht einem einzelnen Zeichen, das nicht in Klammern steht |
\\EIN | Anfang der gesamten Saite |
\\ z | Ende der gesamten Zeichenfolge |
\\ Z. | Ende der gesamten Zeichenfolge mit Ausnahme des zulässigen Abschlussabschlusses. |
Re* | Entspricht 0 oder mehr Vorkommen des vorhergehenden Ausdrucks. |
re + | Entspricht 1 oder mehr der vorherigen Sache |
Re? | Entspricht 0 oder 1 Vorkommen des vorhergehenden Ausdrucks. |
re {n} | Entspricht genau n Vorkommen des vorhergehenden Ausdrucks. |
re {n,} | Entspricht n oder mehr Vorkommen des vorhergehenden Ausdrucks. |
re {n, m} | Entspricht mindestens n und höchstens m Vorkommen des vorhergehenden Ausdrucks. |
a | b | Entspricht entweder a oder b. |
(Re) | Gruppiert reguläre Ausdrücke und merkt sich übereinstimmenden Text. |
(?: re) | Gruppiert reguläre Ausdrücke, ohne sich an übereinstimmenden Text zu erinnern. |
(?> re) | Entspricht einem unabhängigen Muster ohne Rückverfolgung. |
\\ w | Entspricht Wortzeichen. |
\\ W. | Entspricht Nichtwortzeichen. |
\\ s | Entspricht dem Leerzeichen. Entspricht [\ t \ n \ r \ f]. |
\\ S. | Entspricht Nicht-Leerzeichen. |
\\ d | Entspricht den Ziffern. Entspricht [0-9]. |
\\ D. | Entspricht nicht-stelligen. |
\\EIN | Entspricht dem Stringanfang. |
\\ Z. | Entspricht dem Ende der Zeichenfolge. Wenn eine neue Zeile vorhanden ist, stimmt sie kurz vor der neuen Zeile überein. |
\\ z | Entspricht dem Ende der Zeichenfolge. |
\\G | Spielpunkt, an dem das letzte Spiel beendet wurde. |
\\ n | Rückverweis auf Erfassungsgruppennummer "n" |
\\ b | Entspricht den Wortgrenzen außerhalb der Klammern. Entspricht der Rücktaste (0x08) in Klammern. |
\\ B. | Entspricht Nichtwortgrenzen. |
\\ n, \\ t usw. | Entspricht Zeilenumbrüchen, Wagenrückläufen, Tabulatoren usw. |
\\ Q. | Escape (Zitat) alle Zeichen bis zu \\ E. |
\\ E. | Beendet das mit \\ Q begonnene Zitat |
Beispiele für reguläre Ausdrücke
Beispiel | Beschreibung |
---|---|
. | Entspricht einem beliebigen Zeichen außer Newline |
[Rr] uby | Match "Ruby" oder "Ruby" |
reibe [ihr] | Match "Rubin" oder "Rube" |
[aeiou] | Passen Sie einen beliebigen Kleinbuchstaben an |
[0-9] | Entspricht einer beliebigen Ziffer. das gleiche wie [0123456789] |
[az] | Passen Sie einen beliebigen ASCII-Kleinbuchstaben an |
[AZ] | Passen Sie einen beliebigen ASCII-Großbuchstaben an |
[a-zA-Z0-9] | Passen Sie zu einem der oben genannten Punkte |
[^ aeiou] | Passen Sie etwas anderes als einen Kleinbuchstaben an |
[^ 0-9] | Ordnen Sie etwas anderes als eine Ziffer zu |
\\ d | Entspricht einer Ziffer: [0-9] |
\\ D. | Entspricht einer nichtstelligen Zahl: [^ 0-9] |
\\ s | Entspricht einem Leerzeichen: [\ t \ r \ n \ f] |
\\ S. | Nicht-Leerzeichen abgleichen: [^ \ t \ r \ n \ f] |
\\ w | Entspricht einem einzelnen Wortzeichen: [A-Za-z0-9_] |
\\ W. | Entspricht einem Nichtwortzeichen: [^ A-Za-z0-9_] |
Rubin? | Match "rub" oder "ruby": das y ist optional |
Rubin* | Match "rub" plus 0 oder mehr ys |
Rubin + | Match "rub" plus 1 oder mehr ys |
\\ d {3} | Passen Sie genau 3 Ziffern an |
\\ d {3,} | Entspricht 3 oder mehr Ziffern |
\\ d {3,5} | Passen Sie 3, 4 oder 5 Ziffern an |
\\ D \\ d + | Keine Gruppe: + wiederholt \\ d |
(\\ D \\ d) + / | Gruppiert: + wiederholt \\ D \ d Paar |
([Rr] uby (,)?) + | Match "Ruby", "Ruby, Ruby, Ruby" usw. |
Note- dass jeder Backslash zweimal in der obigen Zeichenfolge erscheint. Dies liegt daran, dass in Java und Scala ein einzelner Backslash ein Escape-Zeichen in einem Zeichenfolgenliteral ist und kein reguläres Zeichen, das in der Zeichenfolge angezeigt wird. Anstelle von '\' müssen Sie also '\\' schreiben, um einen einzelnen Backslash in der Zeichenfolge zu erhalten.
Versuchen Sie das folgende Beispielprogramm.
Beispiel
import scala.util.matching.Regex
object Demo {
def main(args: Array[String]) {
val pattern = new Regex("abl[ae]\\d+")
val str = "ablaw is able1 and cool"
println((pattern findAllIn str).mkString(","))
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
able1
Die Ausnahmen von Scala funktionieren wie Ausnahmen in vielen anderen Sprachen wie Java. Anstatt einen Wert auf normale Weise zurückzugeben, kann eine Methode durch Auslösen einer Ausnahme beendet werden. Scala hat jedoch keine Ausnahmen überprüft.
Wenn Sie Ausnahmen behandeln möchten, verwenden Sie einen try {...} catch {...} -Block wie in Java, außer dass der catch-Block Matching verwendet, um die Ausnahmen zu identifizieren und zu behandeln.
Ausnahmen werfen
Das Auslösen einer Ausnahme sieht genauso aus wie in Java. Sie erstellen ein Ausnahmeobjekt und werfen es dann mit demthrow Schlüsselwort wie folgt.
throw new IllegalArgumentException
Ausnahmen fangen
Scala ermöglicht es Ihnen try/catch eine Ausnahme in einem einzelnen Block und führen Sie dann einen Mustervergleich mit ihm durch caseBlöcke. Versuchen Sie das folgende Beispielprogramm, um Ausnahmen zu behandeln.
Beispiel
import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
object Demo {
def main(args: Array[String]) {
try {
val f = new FileReader("input.txt")
} catch {
case ex: FileNotFoundException =>{
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
}
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Missing file exception
Das Verhalten davon try-catchAusdruck ist der gleiche wie in anderen Sprachen mit Ausnahmen. Der Body wird ausgeführt, und wenn er eine Ausnahme auslöst, jeweilscatch Klausel wird der Reihe nach versucht.
Die Endklausel
Sie können einen Ausdruck mit einem umschließen finallyKlausel, wenn Sie möchten, dass Code ausgeführt wird, unabhängig davon, wie der Ausdruck beendet wird. Versuchen Sie das folgende Programm.
Beispiel
import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException
object Demo {
def main(args: Array[String]) {
try {
val f = new FileReader("input.txt")
} catch {
case ex: FileNotFoundException => {
println("Missing file exception")
}
case ex: IOException => {
println("IO Exception")
}
} finally {
println("Exiting finally...")
}
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Missing file exception
Exiting finally...
Ein Extraktor in Scala ist ein Objekt mit einer Methode namens unapplyals eines seiner Mitglieder. Der Zweck dieser nicht angewendeten Methode besteht darin, einen Wert abzugleichen und auseinanderzunehmen. Oft definiert das Extraktorobjekt auch eine duale Methodeapply für Gebäudewerte, aber dies ist nicht erforderlich.
Beispiel
Nehmen wir ein Beispiel für ein Objekt, das beides definiert apply und unapplyMethoden. Die Methode apply hat dieselbe Bedeutung wie immer: Sie verwandelt Test in ein Objekt, das auf Argumente in Klammern angewendet werden kann, genauso wie eine Methode angewendet wird. Sie können also Test ("Zara", "gmail.com") schreiben, um die Zeichenfolge "[email protected]" zu erstellen.
Das unapply Methode ist, was Test Klasse in eine verwandelt extractor und es kehrt den Bauprozess von um apply. Wenn "Apply" zwei Zeichenfolgen verwendet und daraus eine E-Mail-Adresszeichenfolge bildet, nimmt "Unapply" eine E-Mail-Adresse und gibt möglicherweise zwei Zeichenfolgen zurück: dieuser und die domain der Adresse.
Das unapplymuss auch den Fall behandeln, in dem die angegebene Zeichenfolge keine E-Mail-Adresse ist. Aus diesem Grund gibt unapply einen Optionstyp über Zeichenfolgenpaare zurück. Das Ergebnis ist entwederSome (user, domain)Wenn die Zeichenfolge str eine E-Mail-Adresse mit den angegebenen Benutzer- und Domänenteilen ist, oder Keine, wenn str keine E-Mail-Adresse ist. Hier sind einige Beispiele wie folgt.
Syntax
unapply("[email protected]") equals Some("Zara", "gmail.com")
unapply("Zara Ali") equals None
Das folgende Beispielprogramm zeigt ein Extraktionsobjekt für E-Mail-Adressen.
Beispiel
object Demo {
def main(args: Array[String]) {
println ("Apply method : " + apply("Zara", "gmail.com"));
println ("Unapply method : " + unapply("[email protected]"));
println ("Unapply method : " + unapply("Zara Ali"));
}
// The injection method (optional)
def apply(user: String, domain: String) = {
user +"@"+ domain
}
// The extraction method (mandatory)
def unapply(str: String): Option[(String, String)] = {
val parts = str split "@"
if (parts.length == 2){
Some(parts(0), parts(1))
} else {
None
}
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Apply method : [email protected]
Unapply method : Some((Zara,gmail.com))
Unapply method : None
Mustervergleich mit Extraktoren
Wenn auf eine Instanz einer Klasse Klammern mit einer Liste von null oder mehr Parametern folgen, ruft der Compiler die auf applyMethode auf dieser Instanz. Wir können anwenden sowohl in Objekten als auch in Klassen definieren.
Wie oben erwähnt, ist der Zweck der unapplyMethode ist es, einen bestimmten Wert zu extrahieren, den wir suchen. Es macht den umgekehrten Vorgangapplytut. Beim Vergleichen eines Extraktorobjekts mit demmatch Aussage der unapply Methode wird automatisch ausgeführt.
Versuchen Sie das folgende Beispielprogramm.
Beispiel
object Demo {
def main(args: Array[String]) {
val x = Demo(5)
println(x)
x match {
case Demo(num) => println(x+" is bigger two times than "+num)
//unapply is invoked
case _ => println("i cannot calculate")
}
}
def apply(x: Int) = x*2
def unapply(z: Int): Option[Int] = if (z%2==0) Some(z/2) else None
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
10
10 is bigger two times than 5
Scala ist offen für die Verwendung von Java-Objekten und java.io.File ist eines der Objekte, die in der Scala-Programmierung zum Lesen und Schreiben von Dateien verwendet werden können.
Das folgende Beispielprogramm beschreibt das Schreiben in eine Datei.
Beispiel
import java.io._
object Demo {
def main(args: Array[String]) {
val writer = new PrintWriter(new File("test.txt" ))
writer.write("Hello Scala")
writer.close()
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Es wird eine Datei mit dem Namen erstellt Demo.txtim aktuellen Verzeichnis, in dem sich das Programm befindet. Das Folgende ist der Inhalt dieser Datei.
Ausgabe
Hello Scala
Lesen einer Zeile über die Befehlszeile
Manchmal müssen Sie Benutzereingaben vom Bildschirm lesen und dann mit der weiteren Verarbeitung fortfahren. Das folgende Beispielprogramm zeigt Ihnen, wie Sie Eingaben von der Befehlszeile lesen.
Beispiel
object Demo {
def main(args: Array[String]) {
print("Please enter your input : " )
val line = Console.readLine
println("Thanks, you just typed: " + line)
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Please enter your input : Scala is great
Thanks, you just typed: Scala is great
Dateiinhalt lesen
Das Lesen aus Dateien ist wirklich einfach. Sie können Scala verwendenSourceKlasse und ihr Begleitobjekt zum Lesen von Dateien. Das folgende Beispiel zeigt Ihnen, wie Sie lesen können"Demo.txt" Datei, die wir zuvor erstellt haben.
Beispiel
import scala.io.Source
object Demo {
def main(args: Array[String]) {
println("Following is the content read:" )
Source.fromFile("Demo.txt" ).foreach {
print
}
}
}
Speichern Sie das obige Programm in Demo.scala. Die folgenden Befehle werden zum Kompilieren und Ausführen dieses Programms verwendet.
Befehl
\>scalac Demo.scala
\>scala Demo
Ausgabe
Following is the content read:
Hello Scala