Scala LanguageIniziare con Scala Language


Osservazioni

Scala è un moderno linguaggio di programmazione multi-paradigma progettato per esprimere schemi di programmazione comuni in modo conciso, elegante e sicuro per il tipo. Integra perfettamente funzionalità di linguaggi orientati agli oggetti e funzionali .

La maggior parte degli esempi forniti richiede un'installazione di Scala funzionante. Questa è la pagina di installazione di Scala , e questo è l'esempio di 'Come configurare Scala' . scalafiddle.net è una buona risorsa per l'esecuzione di piccoli esempi di codice sul web.

Versioni

Versione Data di rilascio
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

Ciao mondo come una sceneggiatura

Scala può essere usato come linguaggio di scripting. Per dimostrare, crea HelloWorld.scala con il seguente contenuto:

println("Hello")
 

Eseguilo con l'interprete della riga di comando ( $ è il prompt della riga di comando):

$ scala HelloWorld.scala
Hello
 

Se ometti .scala (ad esempio se hai semplicemente digitato scala HelloWorld ) il runner cercherà un file .class compilato con bytecode invece di compilare e quindi eseguire lo script.

Nota: se scala viene utilizzato come linguaggio di scripting, non è possibile definire alcun pacchetto.

Nei sistemi operativi che utilizzano bash o terminali di shell simili, gli script Scala possono essere eseguiti utilizzando un 'preambolo di shell'. Creare un file denominato HelloWorld.sh e inserire quanto segue come contenuto:

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

Le parti tra #! e !# è il 'preambolo della shell', ed è interpretato come uno script di bash. Il resto è Scala.

Una volta salvato il file sopra, devi concederne le autorizzazioni 'eseguibili'. Nella shell puoi fare questo:

$ chmod a+x HelloWorld.sh
 

(Nota che questo dà il permesso a tutti: leggi su chmod per sapere come impostarlo per gruppi di utenti più specifici.)

Ora puoi eseguire lo script in questo modo:

$ ./HelloWorld.sh
 

Ciao mondo definendo un metodo "principale"

Inserisci questo codice in un file denominato HelloWorld.scala :

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

Dimostrazione dal vivo

Per compilarlo in bytecode eseguibile da JVM:

$ scalac HelloWorld.scala
 

Per eseguirlo:

$ scala Hello
 

Quando il runtime di Scala carica il programma, cerca un oggetto chiamato Hello con un metodo main . Il metodo main è il punto di ingresso del programma ed è eseguito.

Nota che, diversamente da Java, Scala non ha bisogno di nominare oggetti o classi dopo il file in cui si trovano. Invece, il parametro Hello passato nel comando scala Hello riferisce all'oggetto da cercare che contiene il metodo main da eseguire. È perfettamente possibile avere più oggetti con i metodi principali nello stesso file .scala .

L'array args conterrà gli argomenti della riga di comando dati al programma, se presenti. Ad esempio, possiamo modificare il programma in questo modo:

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

Compilalo:

$ scalac HelloWorld.scala
 

E poi eseguirlo:

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

Ciao mondo estendendo l'app

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

Dimostrazione dal vivo

Estendendo il tratto App , puoi evitare di definire un metodo main esplicito. L'intero corpo dell'oggetto HelloWorld viene considerato come "il metodo principale".

2.11.0

Inizializzazione ritardata

Secondo la documentazione ufficiale , l' App utilizza una funzionalità denominata inizializzazione ritardata . Ciò significa che i campi dell'oggetto vengono inizializzati dopo che è stato chiamato il metodo principale.

2.11.0

Inizializzazione ritardata

Secondo la documentazione ufficiale , l' App utilizza una funzionalità denominata inizializzazione ritardata . Ciò significa che i campi dell'oggetto vengono inizializzati dopo che è stato chiamato il metodo principale.

DelayedInit è ora deprecato per uso generale, ma è ancora supportato per App come caso speciale. Il supporto continuerà fino a quando non verrà decisa e implementata una funzione sostitutiva.

Per accedere agli argomenti della riga di comando durante l'estensione App , utilizzare this.args :

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

Quando si usa App , il corpo dell'oggetto verrà eseguito come metodo main , non è necessario sovrascrivere il main .

Scala Quicksheet

Descrizione Codice
Assegna valore int immutabile val x = 3
Assegna un valore int mutabile var x = 3
Assegna valore immutabile con tipo esplicito val x: Int = 27
Assegna il valore valutato pigramente lazy val y = print("Sleeping in.")
Associare una funzione a un nome val f = (x: Int) => x * x
Associare una funzione a un nome con tipo esplicito val f: Int => Int = (x: Int) => x * x
Definire un metodo def f(x: Int) = x * x
Definire un metodo con digitazione esplicita def f(x: Int): Int = x * x
Definisci una classe class Hopper(someParam: Int) { ... }
Definisci un oggetto object Hopper(someParam: Int) { ... }
Definisci un tratto trait Grace { ... }
Ottieni il primo elemento della sequenza Seq(1,2,3).head
Se interruttore val result = if(x > 0) "Positive!"
Ottieni tutti gli elementi della sequenza tranne prima Seq(1,2,3).tail
Passa attraverso un elenco for { x <- Seq(1,2,3) } print(x)
Ciclo annidato for {
x <- Seq(1,2,3)
y <- Seq(4,5,6)
} print(x + ":" + y)
Per ogni elemento della lista eseguire la funzione List(1,2,3).foreach { println }
Stampa su standard print("Ada Lovelace")
Ordina una lista alfanumericamente List('b','c','a').sorted

Utilizzo di Scala REPL

Quando esegui scala in un terminale senza parametri aggiuntivi, apre un interprete REPL (Read-Eval-Print Loop):

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> 
 

Il REPL consente di eseguire Scala in un foglio di lavoro: il contesto di esecuzione viene mantenuto ed è possibile provare manualmente i comandi senza dover creare un intero programma. Ad esempio, digitando val poem = "As halcyons we shall be" sarebbe simile a questo:

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

Ora possiamo stampare il nostro val :

scala> print(poem)
As halcyons we shall be
 

Nota che val è immutabile e non può essere sovrascritto:

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

Ma nel REPL è possibile ridefinire un valore val (che causerebbe un errore in un normale programma Scala, se è stato eseguito nello stesso ambito):

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

Per il resto della sessione REPL questa variabile appena definita ombreggia la variabile definita in precedenza. REPL sono utili per vedere rapidamente come funzionano gli oggetti o altro codice. Sono disponibili tutte le funzionalità di Scala: puoi definire funzioni, classi, metodi, ecc.