Variablen in Scala

Tutorials
Scala

Schau dir den neu gestarteten Scala-Kurs von DataCamp an: Einführung in Scala.

Scala wird weit verbreitet von Data Scientists verwendet, wenn es um die Behandlung großer Datenmengen in Verbindung mit Apache Spark im Bereich Big Data geht. Es ist eine Programmiersprache, die sowohl objektorientiert als auch funktional ist und viele andere wesentliche Funktionen aufweist, wie unten aufgeführt:

  1. Scala ist bekannt als statisch typisierte Sprache, in der der Datentyp für die Variable definiert wird, bevor er verwendet wird. Die Typüberprüfung erfolgt während der Kompilierung statt während der Laufzeit.
  2. Es ist auch eine „stark typisierte“ Sprache, wo die Variablen vor einer Operation überprüft werden.
  3. Es unterstützt auch Typinferenz, wo der Compiler den Typ aus dem Ausdruck oder den Literalen ableitet, sodass die Deklaration des Variablentyps optional ist.

In diesem Tutorial wirst du die folgenden Themen abdecken:

Variablen

Variablen sind der Name des Speicherbereichs in der Speicherung und der Compiler legt ein reserviertes Speicherort basierend auf dem Datentyp der jeweiligen Variable fest. Eine Variable wird mit folgender Syntax in Scala deklariert:

val or val variable_name: variable_datatype = value;

In der obigen Syntax kann die Variable auf eine von zwei Weisen definiert werden, indem entweder das Schlüsselwort ‚var‘ oder ‚val‘ verwendet wird. Es besteht aus ‚variable_name‘ als Ihre neue Variable, gefolgt von einem Doppelpunkt. Der Datentyp der Variable ist ‚variable_datatype.‘ Dies kann jeder gültige Datentyp sein. Danach ‚value‘, das Symbol wird assigned zu ‚variable_name.‘

Zum Beispiel:

val varValue: Byte = 8;

Das ‚val‘ ist das Schlüsselwort für die Definition der Variable, und ‚varValue‘ ist der Variablenname. Es ist vom Datentyp ‚Byte‘ und enthält den Wert 8. ‚Byte‘ ist ein 8-bit signiertes Zeichen, das von 2−7 bis 27−1 reicht.

Der ‚variable_datatype‘ oben kann jeder Datentyp sein, der in Scala existiert und sind wie folgt.

  1. Int: Es ist ein 32-bit signiertes (positive oder negative Zahl), das von 2−31 bis 231−1 reicht.
  2. Byte: Es ist ein 8-bit signiertes Zeichen, das von 2−7 bis 27−1 reicht.
  3. Short: Es ist ein 16-bit signiertes Zeichen, das von 2−15 bis 215−1 reicht.
  4. Float: Es kann entweder 32 Bit oder 64 Bit sein.

Ähnlich wie andere Datentypen wie Long, Char, Boolean, Char, String, Boolean, Null besitzen ihre eigenen Bereiche, eine detaillierte Erklärung ist im Leitfaden für Anfänger in Scala gegeben. Des Weiteren sollte der ‚variable_datatype‘ mit einem Großbuchstaben beginnen, d.h., Int enthält ‚I‘, was bedeutet, dass alle oben genannten Datentypen Objekte in Scala sind.

Regeln für die Definition von Variablen in Scala

Die Regeln und Konventionen für die Definition von Variablen in Scala sind wie folgt:

  1. Der Variablenname beginnt mit einem lower camel case. Zum Beispiel im Variablenamen ’nameOfGirl‘ enthält ’n‘ als kleines Alphabet. Danach sollten alle Anfangsbuchstaben der Wörter groß geschrieben werden, wie ‚O‘ und ‚G‘.
  2. Der Variablenname darf kein reserviertes Wort oder Keyword enthalten, das in Scala definiert ist.
  3. Der Variablenname kann Dollarzeichen (‚$‘) und Unterstrich (‚_‘) enthalten. Andere Sonderzeichen wie ‚#‘, ‚&‘, etc., sind jedoch nicht erlaubt. Außerdem wird das Benutzen von Unterstrichen nicht empfohlen.
  4. Leerraum (Tabs, Leerzeichen) ist in Variablennamen nicht erlaubt.
  5. Der Variablenname muss mit einem Buchstaben beginnen und darf nicht mit einer Zahl oder anderen Zeichen anfangen.

Mutable Variablen

Mutable Variablen erlauben es, den Wert von Variablen sogar nach der Deklaration zu ändern.

Die Syntax von Mutable Variablen ist wie folgt dargestellt:

var variable_name : variable_datatype = value;

Die Syntax einer veränderbaren Variable kann auch folgendermaßen definiert werden:

var variable_name = value;

Ein Beispiel für eine veränderbare Variable ist unten gezeigt:

var nameOfThing: String = "Car";

Das obige Beispiel enthält den Schlüsselwort var, das zur Definition veränderbarer Variablen verwendet wird. Der Name der Variable ist ’nameOfThing‘. Dem folgt ein Doppelpunkt mit der Datentypangabe ‚String‘. Ihr Wert im Speicher lautet ‚Car‘.

Ein Beispiel für eine veränderbare Variable mit einer anderen Syntax kann wie unten gezeigt erstellt werden:

var nameOfThing = "Car";

Man kann die Datentypangabe einer Variabelbeiweglassen, wie oben getan. Der Scala-Compiler bestimmt diese automatisch zu einer ‚String‘-Datentyp, was als Typ Inferenz bezeichnet wird.

Man kann den Wert einer Variable leicht ändern, wie unten gezeigt:

nameOfThing = "Bike";
print(nameOfThing)

Der Wert der Variable wechselt von „Car“ zu „Bike“. Der Ausdruck wird „Bike“ sein, weil das Schlüsselwort ‚var‘ erlaubt, den Wert der Variable zu ändern (Quelle: Variablen in Scala).

Unveränderbare Variablen

Unveränderbare Variablen sind solche, deren Wert nach der Erstellung nicht geändert werden kann und mit dem Schlüsselwort ‚val‘ deklariert werden.

Die Syntax einer unveränderbaren Variable ist unten gezeigt:

val variable_name : variable_data type = value;

Die Syntax einer unveränderbaren Variable kann auch folgendermaßen definiert werden:

val variable_name = value;

Ein Beispiel für eine unveränderbare Variable ist unten gezeigt:

val numberOfThing: Int = 2;

Der oben genannte Beispiel enthält val als Schlüsselwort für die Definition unveränderlicher Variablen und den Variablennamen ’numberOfThing‘. Darauf folgt ein Doppelpunkt mit dem Datentyp der Variablen ‚Int‘ nebst dem im Speicher gespeicherten Wert 2.

Der oben genannte Beispiel für eine unveränderliche Variable mit einer anderen Syntax kann wie folgt erstellt werden:

val numberOfThing = 2;

Sie können Ihre Variable ohne den Datentyp definieren, wie oben dargestellt, wobei der Scala-Compiler automatisch erkennt, dass es sich um einen ‚Int‘-Datentyp handelt. Diese Prozedur heißt Typ-Inference (Quelle: Variablen in Scala).

Sie können den Wert der Variable nicht ändern, wie unten dargestellt:

numberOfThing = 7;

Der oben genannte Beispiel führt zu einem Fehler wie „error: not found: value numberOfThing“, was zeigt, dass die Umstellung des Werts nicht möglich ist, wie unten dargestellt:

Mehrere Deklarationen und Zuweisungen

Mehrere Deklarationen sind in Scala möglich, indem Sie den ‚var‘-Schlüsselwort verwenden, die Variablennamen durch Kommas getrennt und den „=“-Zeichen mit dem Wert für die Variable verwenden.

var (x, y, z) = (5, 4.5, "Sit")

In dem oben genannten Beispiel können Sie sehen, dass alle Variablen x, y und z mit den Werten 5, 4,5 und „Sit“ zugewiesen werden, wie folgt:

Mehrere Zuweisungen können in Scala in einer Zeile erfolgen, indem das ‚val‘-Schlüsselwort verwendet wird, die Variablennamen durch Kommas getrennt und der „=“-Zeichen mit dem Wert für die Variable verwendet werden.

val a, b, c = 1;

In dem oben genannten Beispiel können Sie sehen, dass alle Variablen a, b und c mit dem Wert 1 zugewiesen werden, wie folgt:

Der Bereich einer Variablen.

Der Bereich ist die Sichtbarkeit der Variablen, die ihr Lebenszyklus innerhalb der angegebenen Codeblöcke haben. Die Variable kann entweder in lokalem oder globalem Bereich definiert werden. Zum Beispiel:

var globalVar = 10
def sub(){
var difference = 9-4;
}
print(difference)//Fehler
print(globalVar)//Gültig

In dem obigen Code ist die Variable ‚difference‘ im lokalen Bereich, wo sie innerhalb des ’sub‘-Methoden definiert wird, und der Subtraktionsoperation wird gültige Ergebnisse liefern, aber das Drucken des Werts außerhalb des ’sub‘-Methodens wird einen Fehler verursachen. Es gibt auch einen globalen Bereich, in dem die Variable ‚globalVar‘ überall im Programm zugänglich ist und mit ihr jeder Art von Operation durchgeführt werden kann.

Es gibt drei Arten von Bereichsvariablen in Scala (Quelle: Scala- Variablen):

  1. Lokale Variablen
  2. Felder
  3. Methodenparameter

Lokale Variablen

Lokale Variablen sind veränderliche oder unveränderliche Variablen, die innerhalb eines Methods deklariert werden und nur innerhalb von Methoden zugänglich sind, nicht jedoch außerhalb.

Du kannst den einfachen Beispiel unten anschauen, um mehr über lokale Variablen zu erfahren:

class Perimeter  
{
    def triangle()  
    {
        var side1 = 10;
        var side2 = 20;
        var side3 = 30;

        var total = side1+side2+side3;
        print("Perimeter of the  triangle is: " + total);
    }
}

object Test  
{

    def main(args:Array[String])  
    {
        val p1 = new Perimeter()
        p1.triangle()
    }
}

defined class Perimeter
defined object Test

Der obenstehende Code gibt das Ergebnis:

Der Umfang des Dreiecks ist: 60

Das oben genannte Programm enthält eine Klasse namens ‚Perimeter‘ und ein Objekt namens ‚Test‘, in der ein Dreiecks-Method existiert, die drei veränderliche Variablen side1, side2, side3 aufweist. Die Berechnung und das Ausgeben des Ergebnisses wird innerhalb der Methode erfolgen, was das korrekte Ergebnis liefert.

Felder

Diese Variablen, die innerhalb der Klasse definiert sind, werden als Feldvariablen bezeichnet und können jeder Art von Variablen sein, entweder veränderlich oder unveränderlich. Der Zugrimmacher wird automatisch öffentlich sein, wenn die Variable innerhalb der Klasse deklariert wird, sollte aber nicht innerhalb eines Methods definiert werden, wo die Variable überall im Programm zugänglich ist. Eine private Variable kann jedoch innerhalb der definierten Klasse zugegriffen werden, aber nicht außerhalb des Scopes der Klasse oder auch im Objekt.

class FieldExample
{
  var value1 = 10;
  private var value2 = 30;
  def operation()
  {
    println("Value of value1:"+value1)
  }
  println("Value of value2: "+value2);
}

object Demo
{
  def Main(args:Array[String])
  {
    val obj = new FieldExample()
    obj.operation()
    print(obj.value1)//Valid
    print(obj.value2)


  }
}

defined class FieldExample
defined object Demo

Der obige Code gibt das Ergebnis:

Wert von value2: 30
Wert von value1:10
10

Das obige Programm enthält eine Klasse namens ‚FieldExample,‘ ein Objekt namens ‚Demo‘ und eine Methode namens ‚operation.‘ Die öffentliche Variable value1 kann mit Punktnotation aufgerufen werden, und der Wert ist 10. Die private Variable value2 ist 30, wo der Zugriff auf diese Variable und das Ausgeben einen Fehler verursacht.

Methodenparameter

Die Methodenparameter sind Variablen, die den Wert bei der Aufrufung der Methode akzeptieren müssen und veränderlich sind, die mit dem Schlüsselwort ‚val‘ definiert werden. Diese Variable kann auch außerhalb der Methode zugegriffen werden, wenn auf sie ein Verweis gemacht wird.

Du kannst den einfachen Beispiel unten anschauen, um mehr über Methodenparameter zu erfahren:

class Triangle
{
    def calculate(height: Int, width: Int)
    {
        var result = 0.5*(height+width);
        println("Area of triangle is: " + result);
    }
}

object Area  
{
     def main(args:Array[String])
    {
        val a = new Triangle()
        a.calculate(4,5);
    }
}

defined class Triangle
defined object Area

Der obige Code gibt das Ergebnis:

Fläche des Dreiecks ist: 4,5

Das oben stehende Programm enthält eine Klasse namens ‚Triangle.‘ Sie enthält eine Methode namens ‚calculate‘ mit zwei Methodenparametern Höhe und Breite. Der Integer-Wert 4 und 5 werden übergeben, wenn ‚calculate‘ mit der Objektinstanz a aufgerufen wird.

Schlussfolgerung

Herzlichen Glückwunsch, Sie haben es bis zum Ende dieses Tutorials geschafft!

In diesem Tutorial haben Sie sich mit Scalas Variablen, Regelungen für die Definition von Variablen, verschiedenen Arten von Variablen mit mehrfacher Deklaration und Zuweisung sowie dem Gültigkeitsbereich von Variablen beschäftigt.

Wenn Sie mehr über Scala lernen möchten, nehmen Sie den DataCamp-Kurs Einführung in Scala teil.

Source:
https://www.datacamp.com/tutorial/variables-in-scala