Variables Scala
Une variable est un espace réservé pratique utilisé pour référencer une adresse mémoire d'ordinateur. Une fois qu'une variable est créée, elle occupe une certaine quantité d'espace mémoire.
En fonction du type de données de la variable, le système d'exploitation alloue de la mémoire et décide de ce qui sera stocké dans la mémoire réservée. Par conséquent, en attribuant différents types de données aux variables, vous pouvez stocker des entiers, des décimales ou des lettres dans ces variables.
Déclaration de variable
Avant d'apprendre à déclarer des variables et des constantes, commençons par comprendre les variables et les constantes.
- Variable :Une quantité dont la valeur peut changer pendant l'exécution du programme est appelée une variable. Par exemple : le temps, l'âge.
- Constante :Une quantité dont la valeur ne change pas pendant l'exécution du programme est appelée une constante. Par exemple : le nombre 3, le caractère 'A'.
En Scala, utilisez le mot-clé"var"pour déclarer des variables, et utilisez le mot-clé"val"pour déclarer des constantes.
Variable immuable (val) :
- En utilisant la
valmot-clé déclare une variable immuable, ce qui signifie qu'une fois assignée, sa valeur ne peut pas être modifiée. - Semblable à celui de Java
finalvariable.
Variable mutable (var) :
- En utilisant la
varmot-clé déclare une variable mutable, dont la valeur peut être modifiée plusieurs fois pendant la durée de vie du programme. - Semblable aux variables ordinaires en Java.
Un exemple de déclaration d'une variable est le suivant :
var myVar : String = "Foo" var myVar : String = "Too"
Ce qui précède définit la variable myVar, que nous pouvons modifier.
Un exemple de déclaration d'une constante est le suivant :
val myVal : String = "Foo"
Ce qui précède définit la constante myVal, qui ne peut pas être modifiée. Si le programme tente de modifier la valeur de la constante myVal, cela provoquera une erreur de compilation.
Déclaration de type de variable
Le type de la variable est déclaré après le nom de la variable et avant le signe égal. La syntaxe pour définir le type d'une variable est la suivante :
var VariableName : DataType [= Initial Value] 或 val VariableName : DataType [= Initial Value]
Exemple
def main(args: Array[String]): Unit = {
// Déclarer une variable immuable
val immutableVariable: Int = 10
println(s"Variable immuable : $immutableVariable")
// Déclarer une variable mutable
var mutableVariable: Int = 20
println(s"Variable mutable : $mutableVariable")
// Modifier la valeur de la variable mutable
mutableVariable = 30
println(s"Variable mutable mise à jour : $mutableVariable")
// Les variables immuables ne peuvent pas être réaffectées; cela provoquera une erreur de compilation
// immutableVariable = 15 // Décommenter cette ligne provoquera une erreur de compilation
}
}
La sortie du code ci-dessus est :
Immutable Variable: 10 Mutable Variable: 20 Updated Mutable Variable: 30
Conventions de nommage des variables
Caractères autorisés:
- Les noms de variables doivent commencer par une lettre (A-Z ou a-z) ou un trait de soulignement (_).
- Les caractères suivants peuvent être des lettres, des chiffres (0-9) ou des traits de soulignement.
- Les noms de variables ne peuvent pas être des mots-clés Scala.
Nommage en Camel Case:
- Les noms de variables utilisent généralement le camel case, où le premier mot commence par une lettre minuscule et la première lettre des mots suivants est en majuscule.
- Par exemple :
myVariableName,userAge,accountBalance。
Éviter d'utiliser des noms de variables à un seul caractère:
- À l'exception des variables de compteur courantes (telles que
i,j,k), vous devriez éviter autant que possible d'utiliser des noms de variables à un seul caractère pour améliorer la lisibilité du code.
Noms de variables significatifs:
- Les noms de variables doivent exprimer clairement leur but ou leur signification, en évitant les noms vagues ou dénués de sens.
- Par exemple :
val age: Int = 25est meilleur queval a: Int = 25。
Conventions de nommage spécifiques à Scala:
- Essayez d'éviter les noms de variables qui commencent par un trait de soulignement, car ceux-ci sont généralement utilisés pour identifier des variables internes ou privées.
- Des combinaisons de lettres et de symboles peuvent être utilisées pour nommer des fonctions et des méthodes, mais cela est rarement observé dans le nommage des variables.
- Évitez d'utiliser des combinaisons de symboles de type opérateur (telles que
++,--) comme noms de variables, car cela rend le code difficile à lire et à comprendre.
Référence des types de variables
En Scala, il n'est pas nécessaire de spécifier le type de données lors de la déclaration de variables et de constantes. Lorsque le type de données n'est pas spécifié, il est déduit de la valeur initiale de la variable ou de la constante.
Par conséquent, si vous déclarez une variable ou une constante sans spécifier son type de données, vous devez fournir sa valeur initiale ; sinon, une erreur se produira.
- Déclaration explicite du type: Spécifiez explicitement le type de la variable.
- Inférence de type: Omettez la déclaration de type et laissez le compilateur déduire le type.
Le mécanisme d'inférence de type de Scala peut déterminer automatiquement le type d'une variable, nous pouvons donc omettre la déclaration de type :
val inferredInt = 42 // 编译器推断为 Int val inferredDouble = 3.14 // 编译器推断为 Double val inferredString = "Hello, Scala!" // 编译器推断为 String val inferredBoolean = true // 编译器推断为 Boolean
L'inférence de type rend le code plus concis, mais dans des scénarios complexes, des déclarations de type explicites peuvent éviter la confusion.
Pour une déclaration de type explicite, faites suivre le nom de la variable d'un deux-points et du type de données :
val explicitInt: Int = 42 val explicitDouble: Double = 3.14 val explicitString: String = "Hello, Scala!" val explicitBoolean: Boolean = true
La déclaration explicite améliore la lisibilité et la maintenabilité du code, en particulier lorsque les types ne sont pas faciles à inférer ou prêtent à confusion.
Exemple
def main(args: Array[String]): Unit = {
// Déclaration explicite de type
val explicitInt: Int = 42
val explicitDouble: Double = 3.14
val explicitString: String = "Hello, Scala!"
val explicitBoolean: Boolean = true
// Inférence de type
val inferredInt = 42 // Le compilateur infère Int
val inferredDouble = 3.14 // Le compilateur infère Double
val inferredString = "Hello, Scala!" // Le compilateur infère String
val inferredBoolean = true // Le compilateur infère Boolean
// Variable mutable
var mutableInt: Int = 10
println(s"mutableInt initial : $mutableInt")
mutableInt = 20 // Modifier la valeur de la variable
println(s"mutableInt mis à jour : $mutableInt")
// Afficher toutes les variables
println(s"Int explicite : $explicitInt")
println(s"Double explicite : $explicitDouble")
println(s"String explicite : $explicitString")
println(s"Boolean explicite : $explicitBoolean")
println(s"Int inféré : $inferredInt")
println(s"Double inféré : $inferredDouble")
println(s"Chaîne inférée : $inferredString")
println(s"Booléen inféré : $inferredBoolean")
}
}
La sortie du code ci-dessus est :
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
Déclaration de plusieurs variables en Scala
En Scala, vous pouvez déclarer plusieurs variables en même temps. Cela rend non seulement le code plus concis, mais garantit aussi la corrélation de plusieurs variables déclarées sur la même ligne.
En Scala, vous pouvez déclarer plusieurs variables simultanément en utilisant des méthodes telles que la séparation par virgules, la déstructuration de tuples et les for-comprehensions.
Vous pouvez déclarer plusieurs variables sur une seule ligne séparées par des virgules :
val xmax, ymax = 100 // xmax, ymax都声明为100
Exemple
def main(args: Array[String]): Unit = {
// Déclarer plusieurs variables immuables en même temps
val a, b, c: Int = 5
println(s"a: $a, b: $b, c: $c")
// Déclarer plusieurs variables mutables en même temps
var x, y, z: Int = 10
println(s"x: $x, y: $y, z: $z")
// Modifier la valeur des variables mutables
x = 20
y = 30
z = 40
println(s"Updated x: $x, y: $y, z: $z")
}
}
Si la valeur de retour d'une méthode est un tuple, on peut utiliser val pour déclarer un tuple :
scala> val pa = (40,"Foo") pa: (Int, String) = (40,Foo)
Exemple
def main(args: Array[String]): Unit = {
// Utiliser la déstructuration de tuple pour déclarer plusieurs variables en même temps
val (a, b, c) = (1, 2, "hello")
println(s"a: $a, b: $b, c: $c")
// Utiliser la déstructuration de tuple pour déclarer plusieurs variables mutables en même temps
var (x, y, z) = (10, 20, "world")
println(s"x: $x, y: $y, z: $z")
// Modifier la valeur des variables mutables
x = 30
y = 40
z = "Scala"
println(s"Updated x: $x, y: $y, z: $z")
}
}
Déclaration de plusieurs variables à l'aide de compréhensions for
Dans une compréhension for, plusieurs variables peuvent être déclarées simultanément pour l'itération et la génération de nouvelles collections.
Exemple
def main(args: Array[String]): Unit = {
// Déclarer plusieurs variables en même temps pour l'itération
val numbers = List((1, "one"), (2, "two"), (3, "three"))
for ((number, word) <- numbers) {
println(s"Nombre: $number, Mot: $word")
}
// Utiliser une compréhension for pour générer une nouvelle collection
val newNumbers = for {
(number, word) <- numbers
} yield (number * 2, word.toUpperCase)
println(s"Nouveaux nombres : $newNumbers")
}
}