Scala Language Handledning
Komma igång med Scala Language
Sök…
Anmärkningar
Scala är ett modernt programmeringsspråk med flera paradigmer som är utformat för att uttrycka vanliga programmeringsmönster på ett kortfattat, elegant och typsäkert sätt. Den integrerar smidigt funktioner i objektorienterade och funktionella språk.
De flesta givna exempel kräver en fungerande Scala-installation. Det här är Scala-installationssidan och detta är exemplet 'Hur man ställer in Scala' . scalafiddle.net är en bra resurs för att utföra små kodexempel på webben.
versioner
Version | Utgivningsdatum |
---|---|
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 |
Hej värld genom att definiera en "huvudmetod"
Placera den här koden i en fil som heter HelloWorld.scala
:
object Hello {
def main(args: Array[String]): Unit = {
println("Hello World!")
}
}
För att kompilera den till bytekod som kan köras av JVM:
$ scalac HelloWorld.scala
För att köra det:
$ scala Hello
När Scala runtime laddar programmet, ser det för ett objekt som heter Hello
med en main
Den main
metoden är programmet inkörsport och exekveras.
Observera att, till skillnad från Java, har Scala inget krav på att namnge objekt eller klasser efter filen de är i. I stället hänvisar parametern Hello
passeras i kommandot scala Hello
till objektet som ska letas efter som innehåller main
som ska köras. Det är perfekt möjligt att ha flera objekt med huvudmetoder i samma .scala
fil.
args
arrayen kommer att innehålla de kommandoradsargument som ges till programmet, om sådana finns. Till exempel kan vi modifiera programmet så här:
object HelloWorld {
def main(args: Array[String]): Unit = {
println("Hello World!")
for {
arg <- args
} println(s"Arg=$arg")
}
}
Samla det:
$ scalac HelloWorld.scala
Och kör sedan det:
$ scala HelloWorld 1 2 3
Hello World!
Arg=1
Arg=2
Arg=3
Hej världen genom att utvidga appen
object HelloWorld extends App {
println("Hello, world!")
}
Genom att förlänga App
drag , kan du undvika att definiera en explicit main
metod. Hela kroppen på HelloWorld
objektet behandlas som "huvudmetoden".
Försenad initialisering
Enligt den officiella dokumentationen använder
App
en funktion som heter Delayed Initialization . Detta innebär att objektfälten initialiseras efter att huvudmetoden har anropats.
Försenad initialisering
Enligt den officiella dokumentationen använder
App
en funktion som heter Delayed Initialization . Detta innebär att objektfälten initialiseras efter att huvudmetoden har anropats.
DelayedInit
nu föråldrat för allmänt bruk, men fortfarande stöds förApp
som ett specialfall. Support kommer att fortsätta tills en ersättningsfunktion har beslutats och implementerats.
För att få åtkomst till kommandoradsargument vid utvidgning av App
, använd this.args
:
object HelloWorld extends App {
println("Hello World!")
for {
arg <- this.args
} println(s"Arg=$arg")
}
När du använder App
, kommer kroppen av objektet utföras som main
finns det ingen anledning att åsidosätta main
.
Hello World som manus
Scala kan användas som skriptspråk. För att demonstrera, skapa HelloWorld.scala
med följande innehåll:
println("Hello")
Kör det med kommandoradstolkaren ( $
är kommandoradsprompt):
$ scala HelloWorld.scala
Hello
Om du utelämnar .scala
(till exempel om du helt enkelt skrev in scala HelloWorld
) letar löparen efter en kompilerad .class
fil med bytekod istället för att kompilera och sedan köra skriptet.
Obs: Om scala används som skriptspråk kan inget paket definieras.
I operativsystem som använder bash
eller liknande skalterminaler, kan Scala-skript utföras med hjälp av en "shell-ingress". Skapa en fil med namnet HelloWorld.sh
och placera följande som dess innehåll:
#!/bin/sh
exec scala "$0" "$@"
!#
println("Hello")
Delarna mellan #!
och !#
är "shell-ingressen" och tolkas som ett bash-skript. Resten är Scala.
När du har sparat ovanstående fil måste du ge den "körbara" behörigheter. I skalet kan du göra detta:
$ chmod a+x HelloWorld.sh
(Observera att detta ger alla tillåtelse: läs om chmod för att lära dig att ställa in det för mer specifika uppsättningar av användare.)
Nu kan du köra skriptet så här:
$ ./HelloWorld.sh
Använda Scala REPL
När du kör scala
i en terminal utan ytterligare parametrar öppnar det en REPL (Read-Eval-Print Loop) -tolk:
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>
Med REPL kan du köra Scala på ett kalkylblad: exekveringssituationen bevaras och du kan prova kommandon manuellt utan att behöva bygga ett helt program. Genom att skriva val poem = "As halcyons we shall be"
skulle till exempel se ut så här:
scala> val poem = "As halcyons we shall be"
poem: String = As halcyons we shall be
Nu kan vi skriva ut vår val
:
scala> print(poem)
As halcyons we shall be
Observera att val
är oföränderligt och inte kan skrivas över:
scala> poem = "Brooding on the open sea"
<console>:12: error: reassignment to val
poem = "Brooding on the open sea"
Men i REPL kan du definiera en val
(som skulle orsaka ett fel i ett normalt program Scala, om det gjordes i samma omfattning):
scala> val poem = "Brooding on the open sea"
poem: String = Brooding on the open sea
För återstoden av din REPL-session kommer denna ny definierade variabel att skugga den tidigare definierade variabeln. REPL är användbara för att snabbt se hur objekt eller annan kod fungerar. Alla Skalas funktioner är tillgängliga: du kan definiera funktioner, klasser, metoder etc.
Scala Quicksheet
Beskrivning | Koda |
---|---|
Tilldela immutable int-värde | val x = 3 |
Tilldela muterbart int-värde | var x = 3 |
Tilldela immutable-värde med uttrycklig typ | val x: Int = 27 |
Tilldela lata utvärderat värde | lazy val y = print("Sleeping in.") |
Bind en funktion till ett namn | val f = (x: Int) => x * x |
Bind en funktion till ett namn med uttrycklig typ | val f: Int => Int = (x: Int) => x * x |
Definiera en metod | def f(x: Int) = x * x |
Definiera en metod med uttrycklig skrivning | def f(x: Int): Int = x * x |
Definiera en klass | class Hopper(someParam: Int) { ... } |
Definiera ett objekt | object Hopper(someParam: Int) { ... } |
Definiera en egenskap | trait Grace { ... } |
Få det första elementet i sekvensen | Seq(1,2,3).head |
Om växlar | val result = if(x > 0) "Positive!" |
Få alla element i sekvensen utom först | Seq(1,2,3).tail |
Gå igenom en lista | for { x <- Seq(1,2,3) } print(x) |
Nested Looping | for { |
För varje listelement kör funktionen | List(1,2,3).foreach { println } |
Skriv ut till standard ut | print("Ada Lovelace") |
Sortera en lista alfanumeriskt | List('b','c','a').sorted |