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 lavalmot-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 Javafinalvariable.

Variable mutable (var) :

  • En utilisant lavarmot-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

object VariableExample {
  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 quei, 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

object VariableTypesExample {
  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

object MultipleVariables {
  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

object TupleDestructuring {
  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

object ForComprehension {
  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")
  }
}
Autres extensions