Variabelen in Scala

Bekijk DataCamp's recent gelanceerde Scala-cursus: Introduction to Scala.

Scala wordt veel gebruikt door data scientists bij het werken met grote hoeveelheden data in combinatie met Apache Spark binnen het Big Data-domein. Het is zowel een objectgeoriënteerde als een functionele programmeertaal met nog veel meer essentiële eigenschappen, zoals hieronder genoemd:

1. Scala staat bekend als een statisch getypeerde taal, waarbij het gegevenstype voor de variabele wordt gedefinieerd voordat deze wordt gebruikt. De typecontrole vindt plaats tijdens het compileren in plaats van tijdens runtime.
2. Het is ook een "sterk getypeerde" taal, waarbij variabelen worden gecontroleerd voordat er een bewerking op wordt uitgevoerd.
3. Het ondersteunt ook type-inferentie, waarbij de compiler het type afleidt uit de expressie of letterlijke waarden, waardoor het opgeven van het type van een variabele optioneel is.

In deze tutorial komen de volgende onderwerpen aan bod:

• Variabelen
• Regels voor het definiëren van variabelen in Scala
• Mutabele variabelen
• Immutabele variabelen
• Meerdere declaraties en toewijzingen
• Scope van variabelen in Scala

Variabelen

Variabelen zijn benoemde ruimtes in het geheugen; de compiler reserveert een locatie op basis van het gegevenstype van de betreffende variabele. De variabele wordt in Scala als volgt gedeclareerd met de volgende syntax:

val or val variable_name: variable_datatype = value;

In bovenstaande syntax kan de variabele op twee manieren worden gedefinieerd met behulp van het sleutelwoord 'var' of 'val'. Het bestaat uit 'variable_name' als je nieuwe variabele, gevolgd door een dubbele punt. Het gegevenstype van de variabele is 'variable_datatype', wat elk geldig gegevenstype kan zijn. Daarna wordt 'value' toegewezen aan 'variable_name'.

Bijvoorbeeld:

val varValue: Byte = 8;

'val' is het sleutelwoord voor het definiëren van de variabele en 'varValue' is de variabelenaam. Het heeft het gegevenstype 'Byte' en bevat de waarde 8. 'Byte' is een 8-bits signed waarde, met een bereik van 2⁻⁷ tot 2⁷−1.

Het hierboven genoemde 'variable_datatype' kan elk gegevenstype zijn dat in Scala bestaat, zoals hieronder:

1. Int: Is een 32-bits signed (positieve of negatieve waarde), met een bereik van 2⁻³¹ tot 2³¹−1.
2. Byte: Een 8-bits signed waarde met een bereik van 2⁻⁷ tot 2⁷−1.
3. Short: Een 16-bits signed waarde met een bereik van 2⁻¹⁵ tot 2¹⁵−1.
4. Float: Kan 32-bits of 64-bits zijn.

Op dezelfde manier hebben andere gegevenstypen zoals Long, Char, Boolean, Char, String, Boolean, Null elk hun eigen bereik; een gedetailleerde uitleg vind je in de tutorial Beginner’s Guide to Scala. Ook moet 'variable_datatype' met een hoofdletter beginnen, d.w.z. Int begint met een 'I', wat aangeeft dat alle bovenstaande gegevenstypen objecten in Scala zijn.

Regels voor het definiëren van variabelen in Scala

De regels en conventies voor het definiëren van variabelen in Scala zijn als volgt:

1. De variabelenaam gebruikt lowerCamelCase. Bijvoorbeeld: in de variabelenaam 'nameOfGirl' is de 'n' een kleine letter. Daarna kapitaliseer je de beginletters van de volgende woorden, zoals 'O' en 'G'.
2. De variabelenaam mag geen gereserveerd woord of sleutelwoord bevatten dat in Scala is gedefinieerd.
3. De variabelenaam mag een dollarteken ('$') en een underscore ('_') bevatten. Andere speciale tekens zoals '#', '&', enz. zijn niet toegestaan. Het gebruik van underscore wordt bovendien afgeraden.
4. Witruimte (tabs, spaties) is niet toegestaan in een variabelenaam.
5. De variabelenaam moet met een letter beginnen en mag niet met een cijfer of andere tekens beginnen.

Mutabele variabelen

Mutabele variabelen maken het mogelijk om de waarden van variabelen te wijzigen, zelfs nadat ze zijn gedeclareerd.

De syntax van een mutabele variabele is als volgt:

var variable_name : variable_datatype = value;

De syntax van een mutabele variabele kan ook als volgt worden gedefinieerd:

var variable_name = value;

Een voorbeeld van een mutabele variabele zie je hieronder:

var nameOfThing: String = "Car";

Het bovenstaande voorbeeld bevat var als sleutelwoord, dat wordt gebruikt voor het definiëren van mutabele variabelen. De naam van de variabele is 'nameOfThing'. Deze wordt gevolgd door een dubbele punt met als gegevenstype 'String'. De waarde die in het geheugen wordt opgeslagen is 'Car'.

Het bovenstaande voorbeeld van een mutabele variabele met een andere syntax kan als volgt worden geschreven:

var nameOfThing = "Car";

Je kunt je variabele definiëren zonder het gegevenstype op te geven, zoals hierboven gedaan. De Scala-compiler bepaalt dan automatisch dat het om een 'String' gaat; dit heet type-inferentie.

Je kunt de waarde van de variabele eenvoudig wijzigen, zoals hieronder:

nameOfThing = "Bike";
print(nameOfThing)

De waarde van de variabele verandert van "Car" naar "Bike". De output zal "Bike" zijn, omdat het sleutelwoord 'var' je toestaat de waarde van de variabele te wijzigen (Bron: Variables in Scala).

Immutabele variabelen

Immutabele variabelen zijn variabelen waarvan de waarde niet kan worden gewijzigd nadat ze zijn aangemaakt; ze worden gedeclareerd met het sleutelwoord 'val'.

De syntax van een immutabele variabele is als volgt:

val variable_name : variable_data type = value;

De syntax van een immutabele variabele kan ook als volgt worden gedefinieerd:

val variable_name = value;

Een voorbeeld van een immutabele variabele zie je hieronder:

val numberOfThing: Int = 2;

Het bovenstaande voorbeeld bevat val als sleutelwoord voor het definiëren van immutabele variabelen en de variabelenaam 'numberOfThing'. Deze wordt gevolgd door een dubbele punt met als gegevenstype 'Int'; de waarde die in het geheugen is opgeslagen is 2.

Het bovenstaande voorbeeld van een immutabele variabele met een andere syntax kan als volgt worden geschreven:

val numberOfThing = 2;

Je kunt je variabele definiëren zonder het gegevenstype op te geven, zoals hierboven gedaan; de Scala-compiler leidt dan automatisch af dat het om een 'Int' gaat. Dit proces heet type-inferentie (Bron: Variables in Scala).

Je kunt de waarde van de variabele niet wijzigen, zoals hieronder:

numberOfThing = 7;

Het bovenstaande voorbeeld resulteert in een fout zoals "error: not found: value numberOfThing", wat laat zien dat het opnieuw toewijzen van een waarde niet mogelijk is, zoals hieronder weergegeven:

Meerdere declaraties en toewijzingen

Meerdere declaraties zijn in Scala mogelijk met het sleutelwoord 'var', met variabelen gescheiden door komma's en het "="-teken met de waarde voor de variabele.

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

In het bovenstaande voorbeeld zie je dat alle variabelen x, y en z respectievelijk de waarden 5, 4.5 en "Sit" krijgen toegewezen, als volgt.

Ook meerdere toewijzingen zijn in Scala in één regel mogelijk met het sleutelwoord 'val', met variabelen gescheiden door komma's en het "="-teken met de waarde voor de variabele.

val a, b, c = 1;

In het bovenstaande voorbeeld zie je dat alle variabelen a, b en c de waarde 1 krijgen toegewezen, als volgt.

Scope van een variabele

De scope is de zichtbaarheid van variabelen, die hun levensduur hebben binnen de opgegeven codeblokken. Een variabele kan worden gedefinieerd in lokale of globale scope. Bijvoorbeeld:

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

In de bovenstaande code staat de variabele 'difference' in de lokale scope: hij is gedeclareerd binnen de methode 'sub'. De aftrekbewerking geeft daar een geldig resultaat, maar het afdrukken van de waarde buiten de methode 'sub' veroorzaakt een fout. Er is ook een globale scope, waarin de variabele 'globalVar' overal in het programma toegankelijk is en waarop elke bewerking kan worden uitgevoerd.

Er zijn drie soorten scope voor variabelen in Scala (Bron: Scala- Variables):

1. Lokale variabelen
2. Velden
3. Methodeparameters

Lokale variabelen

Lokale variabelen zijn mutabele of immutabele variabelen die binnen een methode worden gedeclareerd en alleen daar toegankelijk zijn, niet erbuiten.

Bekijk het eenvoudige voorbeeld hieronder om meer te weten over lokale variabelen:

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

Bovenstaande code geeft het resultaat:

The perimeter of the triangle is: 60

Het programma hierboven bevat een klasse genaamd 'Perimeter' en een object 'Test' met een methode 'triangle' met drie mutabele variabelen: side1, side2, side3. De berekening en het afdrukken van het resultaat gebeurt binnen de methode, wat de juiste output oplevert.

Velden

Variabelen die binnen de klasse zijn gedefinieerd, worden veldvariabelen genoemd en kunnen van elk type zijn, zowel mutabel als immutabel. De access modifier is automatisch public als de variabele binnen de klasse is gedeclareerd, maar niet binnen een methode; de variabele is dan overal in het programma toegankelijk. Een private variabele kan binnen de gedefinieerde klasse worden benaderd, maar niet buiten de scope van de klasse, ook niet vanuit het object.

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

Bovenstaande code geeft het resultaat:

Value of value2: 30
Value of value1:10
10

Het programma hierboven bevat een klasse genaamd 'FieldExample', een object 'Demo' en een methode 'operation'. De publieke variabele value1 kan met dotnotatie worden benaderd en wordt afgedrukt als 10. De private variabele value2 heeft de waarde 30; het proberen te benaderen en af te drukken daarvan buiten de klasse veroorzaakt een fout.

Methodeparameters

Methodeparameters zijn de variabelen die een waarde ontvangen wanneer de methode wordt aangeroepen; de variabele is immutabel en wordt gedefinieerd met het sleutelwoord 'val'. De variabele kan buiten de methode worden benaderd wanneer er een verwijzing naar wordt gemaakt.

Bekijk het eenvoudige voorbeeld hieronder om meer te weten over methodeparameters:

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

Bovenstaande code geeft het resultaat:

Area of triangle is: 4.5

Het programma hierboven bevat een klasse genaamd 'Triangle'. Deze bevat een methode 'calculate' met twee methodeparameters: height en width. De gehele waarden 4 en 5 worden doorgegeven wanneer 'calculate' wordt aangeroepen via het objectexemplaar a.

Conclusie

Gefeliciteerd, je bent aan het einde van deze tutorial gekomen!

In deze tutorial heb je geleerd over variabelen in Scala, de regels voor het definiëren van variabelen, verschillende soorten variabelen met meerdere declaraties en toewijzingen, en de scope van variabelen.

Wil je meer leren over Scala? Volg dan DataCamp's cursus Introduction to Scala.