Scala LanguageAan de slag met Scala Language


Opmerkingen

Scala is een moderne multi-paradigma programmeertaal die is ontworpen om algemene programmeerpatronen op een beknopte, elegante en typeveilige manier uit te drukken. Het integreert soepel functies van objectgeoriënteerde en functionele talen.

De meeste gegeven voorbeelden vereisen een werkende Scala-installatie. Dit is de Scala-installatiepagina en dit is het voorbeeld 'Scala instellen' . scalafiddle.net is een goede bron voor het uitvoeren van kleine codevoorbeelden via het web.

versies

Versie Publicatiedatum
2.10.1 2013/03/13
2.10.2 2013/06/06
2.10.3 2013/10/01
2.10.4 2014/03/24
2.10.5 2015/03/05
2.10.6 2015/09/18
2.11.0 2014/04/21
2.11.1 2014/05/21
2.11.2 2014/07/24
2.11.4 2014/10/30
2.11.5 2014/01/14
2.11.6 2015/03/05
2.11.7 2015/06/23
2.11.8 2016/03/08
2.11.11 2017/04/19
2.12.0 2016/11/03
2.12.1 2016/12/06
2.12.2 2017/04/19

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
 

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".

2.11.0

Vertraagde initialisatie

Volgens de officiële documentatie maakt App gebruik van een functie genaamd Vertraagde initialisatie . Dit betekent dat de objectvelden worden geïnitialiseerd nadat de hoofdmethode is aangeroepen.

2.11.0

Vertraagde initialisatie

Volgens de officiële documentatie maakt App gebruik van een functie genaamd Vertraagde initialisatie . Dit betekent dat de objectvelden worden geïnitialiseerd nadat de hoofdmethode is aangeroepen.

DelayedInit is nu verouderd voor algemeen gebruik, maar wordt nog steeds voor App ondersteund als een speciaal geval. Ondersteuning zal doorgaan totdat een vervangende functie is bepaald en geïmplementeerd.

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.

Scala Quicksheet

Beschrijving Code
Wijs onveranderlijke int waarde toe val x = 3
Wijs een veranderlijke int-waarde toe var x = 3
Wijs onveranderlijke waarde toe met expliciet type val x: Int = 27
Wijs lui geëvalueerde waarde toe lazy val y = print("Sleeping in.")
Bind een functie aan een naam val f = (x: Int) => x * x
Bind een functie aan een naam met een expliciet type val f: Int => Int = (x: Int) => x * x
Definieer een methode def f(x: Int) = x * x
Definieer een methode met expliciet typen def f(x: Int): Int = x * x
Definieer een klasse class Hopper(someParam: Int) { ... }
Definieer een object object Hopper(someParam: Int) { ... }
Definieer een eigenschap trait Grace { ... }
Ontvang het eerste element van de reeks Seq(1,2,3).head
Als schakelaar val result = if(x > 0) "Positive!"
Krijg alle elementen van de reeks behalve eerst Seq(1,2,3).tail
Loop door een lijst for { x <- Seq(1,2,3) } print(x)
Geneste looping for {
x <- Seq(1,2,3)
y <- Seq(4,5,6)
} print(x + ":" + y)
Voor elk lijstelement voert u de functie uit List(1,2,3).foreach { println }
Standaard afdrukken print("Ada Lovelace")
Sorteer een lijst alfanumeriek List('b','c','a').sorted

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.