Variables en Scala

Découvrez le cours Scala récemment lancé par DataCamp : Introduction to Scala.

Scala est largement utilisé par les data scientists pour traiter les grands volumes de données associés à Apache Spark dans le domaine du Big Data. C’est à la fois un langage orienté objet et fonctionnel, doté de nombreuses fonctionnalités essentielles :

1. Scala est un langage à typage statique : le type de données d’une variable est défini avant son utilisation. La vérification des types s’effectue à la compilation, et non à l’exécution.
2. C’est aussi un langage « fortement typé » où les variables sont vérifiées avant toute opération.
3. Il prend en charge l’inférence de type : le compilateur déduit le type à partir de l’expression ou des littéraux, si bien que déclarer explicitement le type est optionnel.

Dans ce tutoriel, vous allez aborder les sujets suivants :

• Variables
• Règles de définition des variables en Scala
• Variables mutables
• Variables immuables
• Déclarations et affectations multiples
• Portée des variables en Scala

Variables

Les variables sont des espaces nommés en mémoire ; le compilateur réserve un emplacement selon le type de données de la variable correspondante. Une variable se déclare en Scala avec la syntaxe suivante :

val or val variable_name: variable_datatype = value;

Dans la syntaxe ci‑dessus, la variable peut être définie de deux manières, avec le mot‑clé « var » ou « val ». Elle comprend « variable_name » comme nom de la nouvelle variable, suivi d’un deux‑points. Le type de données est « variable_datatype », qui peut être n’importe quel type valide. Ensuite, « value » est affecté à « variable_name ».

Par exemple :

val varValue: Byte = 8;

« val » est le mot‑clé de définition, et « varValue » le nom de la variable. Son type est « Byte » et sa valeur est 8. « Byte » est une valeur signée sur 8 bits, allant de 2⁻⁷ à 2⁷−1.

Le « variable_datatype » ci‑dessus peut être n’importe quel type existant en Scala, par exemple :

1. Int : entier signé sur 32 bits (positif ou négatif), allant de 2⁻³¹ à 2³¹−1.
2. Byte : valeur signée sur 8 bits, allant de 2⁻⁷ à 2⁷−1.
3. Short : valeur signée sur 16 bits, allant de 2⁻¹⁵ à 2¹⁵−1.
4. Float : peut être sur 32 bits ou 64 bits.

De même, d’autres types comme Long, Char, Boolean, String, Null ont chacun leur plage de valeurs. Une explication détaillée est fournie dans le tutoriel Beginner’s Guide to Scala. Notez aussi que « variable_datatype » commence par une majuscule (par exemple « Int » avec un « I »), ce qui reflète le fait que ces types sont des objets en Scala.

Règles de définition des variables en Scala

Les règles et conventions pour définir des variables en Scala sont les suivantes :

1. Le nom de variable utilise le camel case en commençant par une minuscule. Par exemple, « nameOfGirl » commence par « n ». Ensuite, on met en majuscule l’initiale de chaque mot suivant, comme « O » et « G ».
2. Un nom de variable ne doit pas contenir de mot réservé ni de mot‑clé de Scala.
3. Un nom de variable peut contenir le signe dollar (« $ ») et le tiret bas (« _ »). En revanche, d’autres caractères spéciaux comme « # », « & », etc., ne sont pas autorisés. L’usage du tiret bas est par ailleurs déconseillé.
4. Les espaces (tabulations, espaces) sont interdits dans un nom de variable.
5. Un nom de variable doit commencer par une lettre et ne peut pas débuter par un chiffre ou un autre caractère.

Variables mutables

Les variables mutables permettent de modifier leur valeur après leur déclaration.

La syntaxe d’une variable mutable est la suivante :

var variable_name : variable_datatype = value;

La syntaxe d’une variable mutable peut aussi s’écrire :

var variable_name = value;

Exemple de variable mutable :

var nameOfThing: String = "Car";

Dans l’exemple ci‑dessus, var est le mot‑clé pour définir des variables mutables. Le nom de la variable est « nameOfThing ». Il est suivi de deux‑points puis du type « String ». La valeur stockée en mémoire est « Car ».

Le même exemple de variable mutable, avec une autre syntaxe :

var nameOfThing = "Car";

Vous pouvez définir la variable sans préciser explicitement son type, comme ci‑dessus. Le compilateur Scala déduira automatiquement qu’il s’agit d’un « String » : c’est l’inférence de type.

Vous pouvez facilement changer la valeur de la variable comme suit :

nameOfThing = "Bike";
print(nameOfThing)

La valeur passera de « Car » à « Bike ». La sortie affichera « Bike », car le mot‑clé « var » autorise la modification de la valeur (Source : Variables in Scala).

Variables immuables

Les variables immuables sont des variables dont la valeur ne peut pas être modifiée après leur création. Elles se déclarent avec le mot‑clé « val ».

La syntaxe d’une variable immuable est la suivante :

val variable_name : variable_data type = value;

La syntaxe d’une variable immuable peut aussi s’écrire :

val variable_name = value;

Exemple de variable immuable :

val numberOfThing: Int = 2;

Dans l’exemple ci‑dessus, val est le mot‑clé pour définir des variables immuables et le nom de variable est « numberOfThing ». Il est suivi d’un deux‑points et du type « Int ». La valeur stockée en mémoire est 2.

Le même exemple de variable immuable, avec une autre syntaxe :

val numberOfThing = 2;

Vous pouvez définir votre variable sans préciser explicitement le type : le compilateur Scala déterminera qu’il s’agit d’un « Int ». Ce mécanisme s’appelle l’inférence de type (Source : Variables in Scala).

Vous ne pouvez pas changer la valeur de la variable comme ci‑dessous :

numberOfThing = 7;

Cela entraînera une erreur du type « error: not found: value numberOfThing », montrant que la réaffectation n’est pas possible, comme illustré ci‑dessous :

Déclarations et affectations multiples

Les déclarations multiples sont possibles en Scala en utilisant le mot‑clé « var », avec les noms de variables séparés par des virgules, puis le signe « = » et la valeur correspondante.

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

Dans l’exemple ci‑dessus, les variables x, y et z reçoivent respectivement les valeurs 5, 4.5 et « Sit », comme suit.

Les affectations multiples sont également possibles en une seule ligne en Scala avec le mot‑clé « val », des noms séparés par des virgules, puis le signe « = » et la valeur.

val a, b, c = 1;

Dans l’exemple ci‑dessus, les variables a, b et c reçoivent toutes la valeur 1.

Portée d’une variable

La portée définit la visibilité d’une variable et sa durée de vie au sein de blocs de code donnés. Une variable peut être définie en portée locale ou globale. Par exemple :

var globalVar = 10
def sub(){
var difference = 9-4;
}
print(difference)//Error
print(globalVar)//Valid

Dans le code ci‑dessus, la variable « difference » est en portée locale car elle est déclarée dans la méthode « sub » : l’opération de soustraction fonctionne, mais l’afficher en dehors de « sub » provoque une erreur. La portée globale permet, elle, d’accéder à « globalVar » partout dans le programme et d’y appliquer des opérations.

On distingue trois types de portée pour les variables en Scala (Source : Scala- Variables) :

1. Variables locales
2. Champs (fields)
3. Paramètres de méthode

Variables locales

Les variables locales, mutables ou immuables, sont déclarées à l’intérieur d’une méthode et ne sont accessibles qu’à l’intérieur de celle‑ci.

Exemple simple de variables locales :

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

Le code ci‑dessus produit :

The perimeter of the triangle is: 60

Le programme comprend une classe « Perimeter » et un objet « Test », avec une méthode « triangle » déclarant trois variables mutables : side1, side2, side3. Le calcul et l’affichage du résultat se font dans la méthode, ce qui donne la bonne sortie.

Champs

Les variables définies dans une classe sont appelées « champs » (fields) et peuvent être mutables ou immuables. Si une variable est déclarée dans la classe (mais pas dans une méthode), son modificateur d’accès est public par défaut, et elle est accessible partout dans le programme. En revanche, une variable privée est accessible dans la classe où elle est définie, mais pas en dehors de sa portée, y compris depuis un objet.

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

Le code ci‑dessus produit :

Value of value2: 30
Value of value1:10
10

Le programme comporte une classe « FieldExample », un objet « Demo » et une méthode « operation ». La variable publique value1 est accessible via la notation point et sa valeur (10) s’affiche. La variable privée value2 vaut 30 : tenter d’y accéder et de l’imprimer en dehors de la classe génère une erreur.

Paramètres de méthode

Les paramètres de méthode sont des variables qui reçoivent une valeur lors de l’appel de la méthode. Par défaut, les paramètres sont traités comme des valeurs (définies avec « val ») et ne sont pas réaffectables dans le corps de la méthode. Ils peuvent toutefois être utilisés en dehors de la méthode s’ils sont exposés via une référence.

Exemple simple sur les paramètres de méthode :

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

Le code ci‑dessus produit :

Area of triangle is: 4.5

Le programme contient une classe « Triangle ». Elle inclut une méthode « calculate » avec deux paramètres, height et width. Les entiers 4 et 5 sont passés lors de l’appel de « calculate » via l’instance d’objet a.

Conclusion

Bravo, vous êtes arrivé au bout de ce tutoriel !

Ici, vous avez vu les variables en Scala, les règles de définition, les différents types, les déclarations et affectations multiples, ainsi que la portée des variables.

Pour aller plus loin avec Scala, suivez le cours DataCamp Introduction to Scala.