Scala-Variablen

Eine Variable ist ein praktischer Platzhalter, der verwendet wird, um auf eine Computerspeicheradresse zu verweisen. Sobald eine Variable erstellt wurde, belegt sie eine bestimmte Menge an Speicherplatz.

Basierend auf dem Datentyp der Variable weist das Betriebssystem Speicher zu und entscheidet, was im reservierten Speicher gespeichert wird. Daher können Sie durch Zuweisen unterschiedlicher Datentypen zu Variablen Ganzzahlen, Dezimalzahlen oder Buchstaben in diesen Variablen speichern.

Variablendeklaration

Bevor wir lernen, wie man Variablen und Konstanten deklariert, wollen wir zunächst Variablen und Konstanten verstehen.

Variable:Eine Größe, deren Wert sich während der Programmausführung ändern kann, wird als Variable bezeichnet. Zum Beispiel: Zeit, Alter.
Konstante:Eine Größe, deren Wert sich während der Programmausführung nicht ändert, wird als Konstante bezeichnet. Zum Beispiel: die Zahl 3, das Zeichen 'A'.

In Scala verwenden Sie das Schlüsselwort"var", um Variablen zu deklarieren, und das Schlüsselwort"val", um Konstanten zu deklarieren.

Unveränderliche Variable (val):

Mit dervalSchlüsselwort deklariert eine unveränderliche Variable, d. h. sobald sie zugewiesen wurde, kann ihr Wert nicht geändert werden.
Ähnlich wie JavasfinalVariable.

Veränderliche Variable (var):

Mit dervarSchlüsselwort deklariert eine veränderliche Variable, deren Wert während der Laufzeit des Programms mehrfach geändert werden kann.
Ähnlich wie gewöhnliche Variablen in Java.

Ein Beispiel für die Deklaration einer Variablen ist wie folgt:

var myVar : String = "Foo"
var myVar : String = "Too"

Das Obige definiert die Variable myVar, die wir ändern können.

Ein Beispiel für die Deklaration einer Konstanten ist wie folgt:

val myVal : String = "Foo"

Das Obige definiert die Konstante myVal, die nicht geändert werden kann. Wenn das Programm versucht, den Wert der Konstante myVal zu ändern, verursacht es einen Kompilierungsfehler.

Deklaration des Variablentyps

Der Typ der Variablen wird nach dem Variablennamen und vor dem Gleichheitszeichen angegeben. Die Syntax zum Definieren eines Variablentyps ist wie folgt:

var VariableName : DataType [=  Initial Value]

oder 

val VariableName : DataType [=  Initial Value]

Beispiel

object VariableExample {
def main(args: Array[String]): Unit = {
// Unveränderliche Variable deklarieren
val immutableVariable: Int = 10
println(s"Unveränderliche Variable: $immutableVariable")

// Veränderliche Variable deklarieren
var mutableVariable: Int = 20
println(s"Veränderliche Variable: $mutableVariable")

// Wert der veränderlichen Variable ändern
mutableVariable = 30
println(s"Aktualisierte veränderliche Variable: $mutableVariable")

// Unveränderliche Variablen können nicht neu zugewiesen werden; dies führt zu einem Kompilierungsfehler
// immutableVariable = 15 // Das Einkommentieren dieser Zeile führt zu einem Kompilierungsfehler
}
}

Die Ausgabe des obigen Codes ist:

Immutable Variable: 10
Mutable Variable: 20
Updated Mutable Variable: 30

Namenskonventionen für Variablen

Zulässige Zeichen：

Variablennamen müssen mit einem Buchstaben (A-Z oder a-z) oder einem Unterstrich (_) beginnen.
Nachfolgende Zeichen können Buchstaben, Ziffern (0-9) oder Unterstriche sein.
Variablennamen dürfen keine Scala-Schlüsselwörter sein.

Camel-Case-Benennung：

Variablennamen verwenden typischerweise Camel Case, wobei das erste Wort mit einem Kleinbuchstaben beginnt und der erste Buchstabe nachfolgender Wörter großgeschrieben wird.
Zum Beispiel:myVariableName, userAge, accountBalance。

Einzelzeichen-Variablennamen vermeiden：

Mit Ausnahme gängiger Zählervariablen (wie z. B.i, j, k), sollten Sie nach Möglichkeit Variablennamen mit einem einzelnen Zeichen vermeiden, um die Lesbarkeit des Codes zu verbessern.

Aussagekräftige Variablennamen：

Variablennamen sollten ihren Zweck oder ihre Bedeutung klar ausdrücken und dabei vage oder nichtssagende Namen vermeiden.
Zum Beispiel:val age: Int = 25ist besser alsval a: Int = 25。

Scala-spezifische Namenskonventionen：

Vermeiden Sie nach Möglichkeit Variablennamen, die mit einem Unterstrich beginnen, da diese üblicherweise zur Kennzeichnung interner oder privater Variablen verwendet werden.
Kombinationen aus Buchstaben und Symbolen können zum Benennen von Funktionen und Methoden verwendet werden, aber dies ist bei der Benennung von Variablen selten zu sehen.
Vermeiden Sie die Verwendung operatorähnlicher Symbolkombinationen (wie z. B.++，--) als Variablennamen, da der Code dadurch schwer zu lesen und zu verstehen ist.

Variablentyp-Referenz

In Scala ist es nicht notwendig, den Datentyp beim Deklarieren von Variablen und Konstanten anzugeben. Wenn der Datentyp nicht angegeben wird, wird er aus dem Initialwert der Variable oder Konstante abgeleitet.

Wenn Sie daher eine Variable oder Konstante deklarieren, ohne ihren Datentyp anzugeben, müssen Sie ihren Initialwert angeben; andernfalls tritt ein Fehler auf.

Explizite Typdeklaration: Geben Sie den Typ der Variable explizit an.
Typinferenz: Verzichten Sie auf die Typdeklaration und lassen Sie den Compiler den Typ ableiten.

Der Typinferenzmechanismus von Scala kann den Typ einer Variable automatisch bestimmen, sodass wir die Typdeklaration weglassen können:

val inferredInt = 42  // 编译器推断为 Int
val inferredDouble = 3.14  // 编译器推断为 Double
val inferredString = "Hello, Scala!"  // 编译器推断为 String
val inferredBoolean = true  // 编译器推断为 Boolean

Typinferenz macht den Code prägnanter, aber in komplexen Szenarien können explizite Typdeklarationen Verwirrung vermeiden.

Für eine explizite Typdeklaration folgt auf den Variablennamen ein Doppelpunkt und der Datentyp:

val explicitInt: Int = 42
val explicitDouble: Double = 3.14
val explicitString: String = "Hello, Scala!"
val explicitBoolean: Boolean = true

Explizite Deklaration hilft, die Lesbarkeit und Wartbarkeit des Codes zu verbessern, insbesondere wenn Typen nicht leicht abzuleiten oder leicht zu verwechseln sind.

Beispiel

object VariableTypesExample {
def main(args: Array[String]): Unit = {
// Explizite Typdeklaration
val explicitInt: Int = 42
val explicitDouble: Double = 3.14
val explicitString: String = "Hello, Scala!"
val explicitBoolean: Boolean = true

// Typinferenz
val inferredInt = 42 // Compiler leitet Int ab
val inferredDouble = 3.14 // Compiler leitet Double ab
val inferredString = "Hello, Scala!" // Compiler leitet String ab
val inferredBoolean = true // Compiler leitet Boolean ab

// Veränderbare Variable
var mutableInt: Int = 10
println(s"Initialwert von mutableInt: $mutableInt")
mutableInt = 20 // Variablenwert ändern
println(s"Aktualisierter Wert von mutableInt: $mutableInt")

// Alle Variablen ausgeben
println(s"Expliziter Int: $explicitInt")
println(s"Expliziter Double: $explicitDouble")
println(s"Expliziter String: $explicitString")
println(s"Expliziter Boolean: $explicitBoolean")

println(s"Abgeleiteter Int: $inferredInt")
println(s"Abgeleiteter Double: $inferredDouble")
println(s"Abgeleiteter String: $inferredString")
println(s"Abgeleiteter Boolean: $inferredBoolean")
}
}

Die Ausgabe des obigen Codes ist:

Initial mutableInt: 10
Updated mutableInt: 20
Explicit Int: 42
Explicit Double: 3.14
Explicit String: Hello, Scala!
Explicit Boolean: true
Inferred Int: 42
Inferred Double: 3.14
Inferred String: Hello, Scala!
Inferred Boolean: true

Deklarieren mehrerer Variablen in Scala

In Scala können Sie mehrere Variablen gleichzeitig deklarieren. Dies macht den Code nicht nur prägnanter, sondern gewährleistet auch den Zusammenhang mehrerer in derselben Zeile deklarierten Variablen.

In Scala können Sie mehrere Variablen gleichzeitig deklarieren, indem Sie Methoden wie Kommatrennung, Tupel-Destrukturierung und For-Comprehensions verwenden.

Sie können mehrere Variablen in einer Zeile durch Kommas getrennt deklarieren:

val xmax, ymax = 100  // xmax, ymax都声明为100

Beispiel

object MultipleVariables {
def main(args: Array[String]): Unit = {
// Mehrere unveränderliche Variablen gleichzeitig deklarieren
val a, b, c: Int = 5
println(s"a: $a, b: $b, c: $c")

// Mehrere veränderliche Variablen gleichzeitig deklarieren
var x, y, z: Int = 10
println(s"x: $x, y: $y, z: $z")

// Den Wert der veränderlichen Variablen ändern
x = 20
y = 30
z = 40
println(s"Aktualisiert x: $x, y: $y, z: $z")
}
}

Wenn der Rückgabewert einer Methode ein Tupel ist, können wir val verwenden, um ein Tupel zu deklarieren:

scala> val pa = (40,"Foo")
pa: (Int, String) = (40,Foo)

Beispiel

object TupleDestructuring {
def main(args: Array[String]): Unit = {
// Tupel-Destrukturierung verwenden, um mehrere Variablen gleichzeitig zu deklarieren
val (a, b, c) = (1, 2, "hallo")
println(s"a: $a, b: $b, c: $c")

// Tupel-Destrukturierung verwenden, um mehrere veränderliche Variablen gleichzeitig zu deklarieren
var (x, y, z) = (10, 20, "Welt")
println(s"x: $x, y: $y, z: $z")

// Den Wert der veränderlichen Variablen ändern
x = 30
y = 40
z = "Scala"
println(s"Aktualisiert x: $x, y: $y, z: $z")
}
}

Mehrere Variablen mit for-Comprehensions deklarieren

In einer for-Comprehension können mehrere Variablen gleichzeitig für die Iteration und die Generierung neuer Sammlungen deklariert werden.

Beispiel

object ForComprehension {
def main(args: Array[String]): Unit = {
// Mehrere Variablen gleichzeitig für die Iteration deklarieren
val numbers = List((1, "one"), (2, "two"), (3, "three"))
for ((number, word) <- numbers) {
println(s"Number: $number, Word: $word")
}

// Verwende eine for-Comprehension, um eine neue Sammlung zu erzeugen
val newNumbers = for {
(number, word) <- numbers
} yield (number * 2, word.toUpperCase)

println(s"New Numbers: $newNumbers")
}
}

Andere Erweiterungen