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!")
  }
}

Live-demo

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!")
}

Live-demo

Genom att förlänga App drag , kan du undvika att definiera en explicit main metod. Hela kroppen på HelloWorld objektet behandlas som "huvudmetoden".

2.11.0

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.

2.11.0

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ör App 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 {
x <- Seq(1,2,3)
y <- Seq(4,5,6)
} print(x + ":" + y)
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


Modified text is an extract of the original Stack Overflow Documentation
Licensierat under CC BY-SA 3.0
Inte anslutet till Stack Overflow