Variabelen in Scala

Handleidingen
Scala

Zie de onlangs gelanceerde Scala-cursus van DataCamp: Introduction to Scala.

Scala wordt breed gebruikt door data wetenschappers bij het werken met grote hoeveelheden data die samen met Apache Spark in het veld van Big Data worden gebruikt. Het is een programmeertaal die zowel object-georiënteerd als functioneel is, en beschikt over vele andere essentiële functies die hieronder vermeld zijn:

  1. Scala is bekend als een statisch getypeerde taal, waarbij het datatype voor de variabele wordt gedefinieerd voordat deze wordt gebruikt. Het type controleren wordt uitgevoerd tijdens het compileren in plaats van tijdens het uitvoeren.
  2. Het is ook een “sterk getypeerde” taal waarbij de variabelen worden gecontroleerd voordat er een bewerking op wordt uitgevoerd.
  3. Het ondersteunt ook Type Inference, waarbij de compiler het type infereert uit de expressie of literalen, dus het declareren van het type van de variabele is optioneel.

In deze handleiding zul je de volgende onderwerpen behandelen:

Variabelen

Variabelen zijn de genoemde ruimte in de geheugen, en de compiler reserveert een plaats volgens de gegevensoort van de corresponderende variabele. Een variabele wordt aangegeven met de volgende syntaxis in Scala:

val or val variable_name: variable_datatype = value;

In de bovenstaande syntaxis kan de variabele op twee manieren worden gedefinieerd door gebruik te maken van de sleutelwoorden ‘var’ of ‘val’. Dit bestaat uit ‘variabelnaam’ als uw nieuwe variabele, gevolgd door een kolon. Het type van de variabele is ‘variabelgegevenstype’ dat elk geldige gegevenssoort kan zijn. Daarna ‘waarde’, krijgt het symbool de waarde ‘variabelnaam.’

Voorbeeld:

val varValue: Byte = 8;

Het ‘val’ is het sleutelwoord voor het definiëren van de variabele, en ‘varValue’ is de variabelenaam. Het is van het type ‘Byte’ en bevat de waarde 8. ‘Byte’ is een 8-bit getekende waarde, die varieert van 2−7 tot 27−1.

Het ‘variabelgegevenstype’ boven kan elke bestaande gegevenssoort zijn in Scala en zijn als volgt.

  1. Int: Is een 32-bit getekende waarde (positief of negatief), die varieert van 2−31 tot 231−1.
  2. Byte: Het is een 8-bit getekende waarde, die varieert van 2−7 tot 27−1.
  3. Short: Het is een 16-bit getekende waarde, die varieert van 2−15 tot 215−1.
  4. Float: Het kan zijn van 32 of 64 bit.

Op analoge wijze omvatten andere data typen zoals Long, Char, Boolean, Char, String, Boolean, Null hun eigen bereik, en wordt een gedetailleerde uitleg gegeven in de Beginners Guide to Scala handleiding. Ook moet de ‘variable_datatype’ beginnen met een hoofdletter, d.w.z., Int bevat ‘I’, wat aangeeft dat alle bovengenoemde data types objecten zijn in Scala.

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 variabelnaam begint met een kleine lettergesp. Bijvoorbeeld, in de variabelenaam ‘nameOfGirl’ bevat ‘n’ de kleine letter. Daarna worden alle beginletters van het woord gecapitaliseerd, zoals ‘O’ en ‘G’.
  2. De variabelnaam mag geen gereserveerde woord of sleutelwoord bevatten zoals gedefinieerd in Scala.
  3. De variabelnaam mag een dollarteken (‘$’) en een underscore (‘_’) bevatten. Echter, andere speciale tekens zoals ‘#’, ‘&’, etc. zijn niet toegestaan. Ook wordt het gebruik van underscore afgeraden.
  4. Lege ruimte (tabellen, spaties) is niet toegestaan in een variabelenaam.
  5. De variabelnaam moet beginnen met een letter en mag niet beginnen met een nummer of andere tekens.

Veranderbare Variabelen

Veranderbare variabelen staan toe om de waarden van variabelen te veranderen zelfs nadat de variabelen zijn gedeclareerd.

Het syntaxis voor een veranderbare variabele is weergegeven hieronder:

var variable_name : variable_datatype = value;

De syntaxis van een wijzigbare variabele kan ook als volgt worden gedefinieerd:

var variable_name = value;

Het voorbeeld van een wijzigbare variabele wordt hieronder weergegeven:

var nameOfThing: String = "Car";

Het bovenstaande voorbeeld bevat var als een sleutelwoord, dat gebruikt wordt voor het definiëren van wijzigbare variabelen. De naam van de variabele is ‘nameOfThing’. Daarna volgt een dubbele punt met het gegevenstype van de variabele als ‘String’. Het opgeslagen waarde in het geheugen zal ‘Car’ zijn.

De bovenstaande wijzigbare variabele met een andere syntaxis kan als volgt worden uitgevoerd:

var nameOfThing = "Car";

U kunt de variabele definiëren zonder het gegevenstype van de variabele, zoals hierboven gedaan. De Scala-compiler zal het automatisch als een ‘String’-gegevenstype bepalen, wat Type Inference wordt genoemd.

U kunt gemakkelijk de waarde van de variabele wijzigen, zoals hieronder weergegeven:

nameOfThing = "Bike";
print(nameOfThing)

De waarde van de variabele zal veranderen van “Car” naar “Bike”. Het resultaat zal “Bike” zijn, omdat het sleutelwoord ‘var’ u toestaat de waarde van de variabele te wijzigen (Bron: Variables in Scala).

Onwijzigbare Variabelen

Onwijzigbare variabelen zijn variabelen waarvan de waarde niet kan worden gewijzigd als deze eenmaal zijn gemaakt en zijn gedeclareerd met het sleutelwoord ‘val’.

De syntaxis van de onwijzigbare variabele wordt hieronder weergegeven:

val variable_name : variable_data type = value;

De syntaxis van de onwijzigbare variabele kan ook als volgt worden gedefinieerd:

val variable_name = value;

Het voorbeeld van de onwijzigbare variabele wordt hieronder weergegeven:

val numberOfThing: Int = 2;

Het bovenstaande voorbeeld bevat val als een sleutelwoord voor het definiëren van onveranderlijke variabelen en de naam van de variabele is ‘numberOfThing’. Het wordt gevolgd door een kolon met het datatype van de variabele als ‘Int’ en de waarde in de geheugen wordt opgeslagen is 2.

Het bovenstaande voorbeeld van een onveranderlijke variabele met een andere syntaxis kan als volgt worden uitgevoerd:

val numberOfThing = 2;

U kunt uw variabele zonder het datatype van de variabele definiëren, zoals hierboven gedaan, waar de Scala-compiler automatisch uitgaat dat het een ‘Int’-datatype is. Het proces wordt aangeduid als Type Inference (bron: Variables in Scala).

U kunt de waarde van de variabele niet veranderen, zoals hieronder wordt gedaan:

numberOfThing = 7;

Het bovenstaande voorbeeld zal resulteren in een foutmelding zoals “fout: niet gevonden: waarde numberOfThing”, wat aangeeft dat de herwaardering van de waarde onmogelijk is, zoals getoond hieronder:

Meerdere Declaraties en Toewijzingen

Meerdere declaraties zijn mogelijk in Scala met behulp van het keyword ‘var’ met de variabelenamen 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 de waarden 5, 4.5 en “Sit” bij elkaar krijgen toegekend als volgt:

Meerdere toewijzingen zijn mogelijk in Scala in één regel door het gebruik van het keyword ‘val’ met de variabelenamen 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 toegekend als volgt:

Het bereik van een variabele.

De scope is de zichtbaarheid van de variabelen die hun levensduur hebben binnen de gespecificeerde blokken van de code. De variabele kan worden gedefinieerd in een lokale of globale scope. Bijvoorbeeld:

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

In de bovenstaande code bevindt de variabele ‘difference’ zich in de lokale scope waar deze wordt gedeclareerd binnen de methode ‘sub’, en de aftrekoperatie zal geldige resultaten geven, maar het afdrukken van de waarde buiten de methode ‘sub’ zal een fout veroorzaken. Er is ook een globale scope waar de variabele ‘globalVar’ overal in het programma kan worden benaderd, en elke bewerking kan erop worden uitgevoerd.

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

  1. Lokale variabelen
  2. Velden
  3. Methodeparameters

Lokale variabelen

Lokale variabelen zijn veranderlijke of onveranderlijke variabelen die binnen een methode worden gedeclareerd en alleen binnen methoden toegankelijk zijn, maar niet daarbuiten.

Je kunt het eenvoudige voorbeeld hieronder zien om meer te weten te komen 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

De bovenstaande code geeft het resultaat:

De omtrek van de driehoek is: 60

Het bovenstaande programma bevat een klasse genaamd ‘Perimeter’ en een object genaamd ‘Test’ waarin er een methode is genaamd triangle met drie veranderlijke variabelen als side1, side2, side3. De berekening en het afdrukken van het resultaat zullen binnen de methode worden gedaan, wat de juiste output zal geven.

Velden

De variabelen die binnen de klasse zijn gedefinieerd, zijn bekend als veldvariabelen en kunnen van elk type zijn, ofwel veranderlijke of onveranderlijke variabelen. Het toegangsmodificeerder is automatisch public als de variabele binnen de klasse wordt gedeclareerd, maar niet binnen een methode waar de variabele overal in het programma toegankelijk is. Echter, een private variabele kan binnen de gedefinieerde klasse worden bereikt, maar niet buiten het bereik van de klasse of zelfs binnen 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

De bovenstaande code geeft het resultaat:

Waarde van value2: 30
Waarde van value1:10
10

Het programma hierboven bevat een klasse genaamd ‘FieldExample’, object genaamd ‘Demo’ en een methode genaamd ‘operation’. De publieke variabele value1 kan met behulp van puntnotatie worden bereikt, en de waarde wordt afgedrukt als 10. De private variabele value2 is 30, waarbij het bereiken van die variabele en afdrukken leidt tot een fout.

Methodeparameters

De methodeparameters zijn de variabelen die de waarde aanvaarden wanneer de methode wordt aangeroepen, en de variabele moet veranderlijk zijn, gedefinieerd met behulp van het sleutelwoord ‘val’. Ook kan de variabele buiten de methode worden bereikt wanneer er een verwijzing naar wordt gemaakt.

Je kunt het onderstaande eenvoudige voorbeeld bekijken om meer te weten te komen 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

De bovenstaande code geeft het resultaat:

Oppervlakte van driehoek is: 4.5

De bovenstaande code bevat een klasse genaamd ‘Triangle’. Het bevat een methode genaamd ‘calculate’ met twee methodeparameters hoogte en breedte. De gehele waarden 4 en 5 worden doorgegeven wanneer ‘calculate’ wordt aangeroepen met objectinstance a.

Conclusie

Gefeliciteerd, je bent bij het einde van deze handleiding beland!

In deze handleiding hebt je informatie over Scala’s variabelen, regels voor het definiëren van variabelen, verschillende typen variabelen met meervoudige declaratie en toewijzingen samen met de scope van de variabele.

Als je meer wilt leren over Scala, neem dan de DataCamp-cursus Introductie tot Scala.

Source:
https://www.datacamp.com/tutorial/variables-in-scala