Scala Language Zelfstudie
Aan de slag met Scala Language

Opmerkingen

versies

Hallo wereld door een 'hoofd'-methode te definiëren

Plaats deze code in een bestand met de naam HelloWorld.scala :

object Hello {
  def main(args: Array[String]): Unit = {
    println("Hello World!")
  }
}

Live demonstratie

Om het te compileren naar bytecode die uitvoerbaar is door de JVM:

$ scalac HelloWorld.scala

Om het uit te voeren:

$ scala Hello

Wanneer de Scala runtime laadt het programma, het ziet er voor een object met de naam Hello met een main methode. De main methode is het programma-invoerpunt en wordt uitgevoerd.

Merk op dat Scala, anders dan Java, geen behoefte heeft om objecten of klassen een naam te geven naar het bestand waarin ze zich bevinden. In plaats daarvan verwijst de parameter Hello doorgegeven in de opdracht scala Hello naar het te zoeken object dat de main methode bevat die moet worden uitgevoerd. Het is perfect mogelijk om meerdere objecten met hoofdmethoden in hetzelfde .scala bestand te hebben.

De args array bevat de eventuele opdrachtregelargumenten die aan het programma zijn gegeven. We kunnen het programma bijvoorbeeld als volgt wijzigen:

object HelloWorld {
  def main(args: Array[String]): Unit = {
    println("Hello World!")
    for {
      arg <- args
    } println(s"Arg=$arg")
  }
}

Compileer het:

$ scalac HelloWorld.scala

En voer het vervolgens uit:

$ scala HelloWorld 1 2 3
Hello World!
Arg=1
Arg=2
Arg=3

Hallo wereld door de app uit te breiden

object HelloWorld extends App {
  println("Hello, world!")
}

Live demonstratie

Door de uitbreiding van de App eigenschap , kunt u voorkomen dat het definiëren van een expliciete main methode. De volledige inhoud van het HelloWorld object wordt behandeld als "de hoofdmethode".

Gebruik this.args om toegang te krijgen tot opdrachtregelargumenten bij het uitbreiden van de App :

object HelloWorld extends App {
  println("Hello World!")
  for {
    arg <- this.args
  } println(s"Arg=$arg")
}

Wanneer u de App , wordt de hoofdtekst van het object als de main methode uitgevoerd. Het is niet nodig om het main te overschrijven.

Hallo wereld als een script

Scala kan worden gebruikt als een scripttaal. Maak om te demonstreren HelloWorld.scala met de volgende inhoud:

println("Hello")

Voer het uit met de opdrachtregelinterpreter (de $ is de opdrachtregelprompt):

$ scala HelloWorld.scala
Hello

Als u .scala (bijvoorbeeld als u simpelweg scala HelloWorld hebt getypt), zoekt de runner naar een gecompileerd .class bestand met bytecode in plaats van te compileren en vervolgens het script uit te voeren.

Opmerking: als scala als scripttaal wordt gebruikt, kan geen pakket worden gedefinieerd.

In besturingssystemen die bash of vergelijkbare shell-terminals gebruiken, kunnen Scala-scripts worden uitgevoerd met behulp van een 'shell-preambule'. Maak een bestand met de naam HelloWorld.sh en plaats het volgende als inhoud:

#!/bin/sh
exec scala "$0" "$@"
!#
println("Hello")

De delen tussen #! en !# is de 'shell preambule' en wordt geïnterpreteerd als een bash-script. De rest is Scala.

Nadat u het bovenstaande bestand hebt opgeslagen, moet u het 'uitvoerbare' machtigingen verlenen. In de shell kunt u dit doen:

$ chmod a+x HelloWorld.sh

(Merk op dat dit iedereen toestemming geeft: lees over chmod om te leren hoe het in te stellen voor meer specifieke sets van gebruikers.)

Nu kunt u het script als volgt uitvoeren:

$ ./HelloWorld.sh

Gebruik van de Scala REPL

Wanneer u scala in een terminal uitvoert zonder aanvullende parameters, wordt een REPL -interpreter (Read-Eval-Print Loop) geopend:

nford:~ $ scala
Welcome to Scala 2.11.8 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_66).
Type in expressions for evaluation. Or try :help.

scala> 

Met de REPL kunt u Scala op een werkblad-manier uitvoeren: de uitvoeringscontext blijft behouden en u kunt handmatig opdrachten uitproberen zonder een heel programma te hoeven bouwen. Bijvoorbeeld, door val poem = "As halcyons we shall be" typen zou dit er als volgt uitzien:

scala> val poem = "As halcyons we shall be"
poem: String = As halcyons we shall be

Nu kunnen we onze val afdrukken:

scala> print(poem)
As halcyons we shall be

Merk op dat val onveranderlijk is en niet kan worden overschreven:

scala> poem = "Brooding on the open sea"
<console>:12: error: reassignment to val
       poem = "Brooding on the open sea"

Maar in de REPL kunt u een val opnieuw definiëren (wat een fout zou veroorzaken in een normaal Scala-programma, als het in dezelfde scope werd gedaan):

scala> val poem = "Brooding on the open sea"
poem: String = Brooding on the open sea

Voor de rest van uw REPL-sessie zal deze nieuw gedefinieerde variabele de eerder gedefinieerde variabele overschaduwen. REPL's zijn handig om snel te zien hoe objecten of andere code werkt. Alle functies van Scala zijn beschikbaar: u kunt functies, klassen, methoden, enz. Definiëren.

Scala Quicksheet