Variables en Scala

Examinez le nouveau cours de Scala de DataCamp : Introduction à Scala.

Scala est largement utilisé par les data scientists lorsqu’ils manipulent de grandes quantités de données avec Apache Spark dans le domaine du Big Data. C’est à la fois un langage orienté objet et fonctionnel avec de nombreuses autres fonctionnalités essentielles, telles que :

1. Scala est connu pour être un langage typé statiquement, où le type de données pour la variable est défini avant qu’il ne soit utilisé. La vérification du type est faite à la compilation plutôt qu’à l’exécution.
2. Il s’agit également d’un langage « fortement typé » où les variables sont vérifiées avant qu’une opération ne soit effectuée sur elles.
3. Il supporte également l’inférence de type, où le compilateur déduit le type de l’expression ou des littéraux, ce qui rend la déclaration du type de variable optionnelle.

Dans ce tutoriel, vous allez aborder les sujets suivants :

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

Variables

Une variable est un espace nommé dans la mémoire, et le compilateur alloue un emplacement réservé en fonction du type de données de la variable correspondante. Une variable est déclarée avec la syntaxe suivante en Scala :

val or val variable_name: variable_datatype = value;

Dans la syntaxe ci-dessus, la variable peut être définie de deux façons différentes en utilisant soit le mot-clé ‘var’ soit ‘val’. Il se compose de ‘variable_name’ comme nouvelle variable, suivi d’une colonne. Le type de données de la variable est ‘variable_datatype.’ qui peut être n’importe quelle type de données valide. Après cela, ‘value’, le symbole est affecté à ‘variable_name.’

Par exemple :

val varValue: Byte = 8;

Le ‘val’ est le mot-clé pour définir la variable, et ‘varValue’ est le nom de la variable. Il est de type ‘Byte’ et contient la valeur 8. ‘Byte’ est une valeur signée de 8 bits, qui vaut entre 2⁻⁷ et 2⁷−1.

Le ‘variable_datatype’ ci-dessus peut être de n’importe quel type de données existant en Scala et sont les suivants :

1. Int : Est une valeur signée de 32 bits (nombre positif ou négatif), qui vaut entre 2⁻³¹ et 2³¹−1.
2. Byte : C’est une valeur signée de 8 bits qui vaut entre 2⁻⁷ et 2⁷−1.
3. Short : C’est une valeur signée de 16 bits qui vaut entre 2⁻¹⁵ et 2¹⁵−1.
4. Float : Il peut être de 32 bits ou de 64 bits.

De même, d’autres types de données tels que Long, Char, Boolean, Char, String, Boolean, Null ont leur propre plage et une explication détaillée est fournie dans le tutoriel Beginner’s Guide to Scala. De plus, le ‘variable_datatype’ doit commencer par une lettre majuscule, c’est-à-dire que Int contient ‘I’, ce qui indique que tous les types de données ci-dessus sont des objets en Scala.

Règles définissant les variables en Scala

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

1. Le nom de la variable commence par une lettre minuscule. Par exemple, dans le nom de variable ‘nameOfGirl,’ la lettre ‘n’ est la première lettre minuscule. Ensuite, tous les caractères initiaux des mots sont en majuscule, comme ‘O’ et ‘G’.
2. Le nom de la variable ne doit pas contenir de mot réservé ou de mot-clé défini en Scala.
3. Le nom de la variable peut contenir le signe dollar (`$’) et le signe underscore (`_’). Cependant, d’autres caractères spéciaux tels que ‘#’, ‘&’, etc., ne sont pas autorisés. De plus, l’utilisation d’underscore est découragée.
4. Les espaces (tabulations, espaces) ne sont pas autorisés dans un nom de variable.
5. Le nom de la variable doit commencer par une lettre et ne peut pas commencer par un numéro ou d’autres caractères.

Variables mutables

Les variables mutables permettent de modifier les valeurs des variables même après leur déclaration.

La syntaxe de la variable mutable est indiquée ci-dessous :

var variable_name : variable_datatype = value;

La syntaxe de la variable mutable peut également être définie comme suit :

var variable_name = value;

Un exemple de variable mutable est présenté ci-dessous :

var nameOfThing: String = "Car";

L’exemple précédent contient le mot-clé var, qui est utilisé pour définir des variables mutables. Le nom de la variable est ‘nameOfThing’. Un point d’interrogation le suit avec le type de données de la variable, ici ‘String’. Sa valeur stockée en mémoire sera ‘Car’.

L’exemple de variable mutable avec une syntaxe différente peut être effectué comme suit :

var nameOfThing = "Car";

Vous pouvez définir votre variable sans le type de données de la variable, comme il a été fait ci-dessus. Le compilateur Scala détermine automatiquement qu’il s’agit du type ‘String’, ce qui est appelé Inférence de type.

Vous pouvez facilement modifier la valeur de la variable, comme illustré ci-dessous :

nameOfThing = "Bike";
print(nameOfThing)

La valeur de la variable passera de « Car » à « Bike ». L’affichage sera « Bike », car le mot-clé ‘var’ permet de modifier la valeur de la variable (source : Variables en Scala).

Variables immutables

Les variables immuables sont celles dont la valeur ne peut être modifiée une fois créée et qui sont déclarées à l’aide du mot-clé ‘val’.

La syntaxe de la variable immutable est présentée ci-dessous :

val variable_name : variable_data type = value;

La syntaxe de la variable immuable peut également être définie comme suit :

val variable_name = value;

Un exemple de variable immuable est présenté ci-dessous :

val numberOfThing: Int = 2;

L’exemple ci-dessus contient val en tant que mot-clé pour définir des variables immuables et le nom d’une variable est ‘numberOfThing.’ Il est suivi d’une colonne avec le type de données de la variable étant ‘Int’ ainsi que la valeur stockée en mémoire est 2.

L’exemple précédent d’une variable immuable avec une syntaxe différente peut être effectué comme suit:

val numberOfThing = 2;

Vous pouvez définir votre variable sans le type de données de la variable, comme indiqué ci-dessus, où le compilateur Scala détermine automatiquement qu’il s’agit du type de données ‘Int’. Ce processus est appelé Inférence de type (Source: Variables dans Scala).

Vous ne pouvez pas modifier la valeur de la variable comme illustré ci-dessous:

numberOfThing = 7;

L’exemple ci-dessus entraînera une erreur semblable à « erreur: introuvable: valeur numberOfThing », ce qui montre que la réaffectation de la valeur est impossible comme illustré ci-dessous :

Déclarations et affectations multiples

Il est possible de faire des déclarations multiples en Scala en utilisant le mot-clé ‘var’ avec les noms de variables séparés par des virgules et le signe « = » avec la valeur de la variable.

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

Dans l’exemple ci-dessus, vous pouvez voir que toutes les variables x, y et z sont affectées à la valeur 5, 4,5 et « Sit » respectivement comme suit.

Les affectations multiples sont possibles en Scala en une seule ligne en utilisant le mot-clé ‘val’ avec les noms de variables séparés par des virgules et le signe « = » avec la valeur de la variable.

val a, b, c = 1;

Dans l’exemple ci-dessus, vous pouvez voir que toutes les variables a, b et c sont affectées à la valeur 1 comme suit.

La portée d’une variable.

Le scope est la visibilité des variables qui ont leur durée de vie à l’intérieur des blocs de code spécifiés. La variable peut être définie dans un scope Local ou Global. Par exemple :

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

Dans le code ci-dessus, la variable ‘difference’ est dans un scope Local où elle est déclarée à l’intérieur de la méthode ‘sub’. L’opération de soustraction donnera des résultats valides, mais imprimer la valeur en dehors de la méthode ‘sub’ provoquera une erreur. Il existe également un scope Global où la variable ‘globalVar’ peut être accédée n’importe où dans le programme, et toutes les opérations peuvent être effectuées sur elle.

Il existe trois types d’ scope pour les variables en Scala (Source : Scala- Variables) :

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

Variables locales

Les variables locales sont des variables mutables ou immuables qui sont déclarées à l’intérieur d’une méthode et ne peuvent être accessibles que à l’intérieur des méthodes, mais pas à l’extérieur.

Vous pouvez voir l’exemple simple ci-dessous pour en savoir plus sur les 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 donne le résultat :

Le périmètre du triangle est : 60

Le programme ci-dessus contient une classe appelée ‘Perimeter’ et un objet ‘Test’ où il y a une méthode appelée triangle avec trois variables mutables comme side1, side2, side3. La calculatation et l’affichage du résultat seront effectués à l’intérieur de la méthode, ce qui donnera le résultat correct.

Champs

Les variables définies à l’intérieur de la classe sont connues sous le nom de champs de classe, qui peuvent être de n’importe quelle type, soit des variables mutables ou immuables. Le modificateur d’accès sera automatiquement public si la variable est déclarée à l’intérieur de la classe, mais il ne devrait pas être défini à l’intérieur de n’importe quelle méthode où la variable est accessible partout dans le programme. Cependant, une variable privée peut être accessible à l’intérieur de la classe définie mais ne peut pas être accessible en dehors de la portée de la classe, ni même dans l’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 donne le résultat :

Valeur de value2 : 30
Valeur de value1 : 10
10

Le programme ci-dessus contient une classe appelée ‘FieldExample,’ un objet appelé ‘Demo’ et une méthode appelée ‘operation.’ La variable publique value1 peut être accédée à l’aide de la notation pointée, et la valeur est imprimée comme 10. La variable privée value2 est de valeur 30, où l’accès à cette variable et son affichage entraînera une erreur.

Paramètres de méthode

Les paramètres de méthode sont les variables qui acceptent la valeur lorsque la méthode est appelée, et la variable doit être mutable, définie à l’aide du mot-clé ‘val’. De plus, la variable peut être accessible en dehors de la méthode lorsqu’il y a une référence à elle.

Vous pouvez voir l’exemple simple ci-dessous pour en savoir plus 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 donne le résultat :

Surface du triangle : 4,5

Le programme ci-dessus contient une classe appelée ‘Triangle’. Elle inclut une méthode appelée ‘calculate’ avec deux paramètres de méthode height et width. Les valeurs entières 4 et 5 sont passées lorsque ‘calculate’ est appelé en utilisant l’instance d’objet a.

Conclusion

Félicitations, vous êtes arrivé à la fin de ce didacticiel !

Dans ce didacticiel, vous avez couvert les variables de Scala, les règles pour définir les variables, les différents types de variables avec des déclarations multiples et des affectations ainsi que la portée de la variable.

Si vous voulez en apprendre davantage sur Scala, prenez le cours de DataCamp Introduction à Scala.