Scala LanguageDémarrer avec le langage Scala


Remarques

Scala est un langage de programmation multi-paradigme moderne conçu pour exprimer des modèles de programmation communs de manière concise, élégante et sûre. Il intègre en douceur les fonctionnalités des langages orientés objet et fonctionnels .

La plupart des exemples donnés nécessitent une installation Scala fonctionnelle. Ceci est la page d'installation de Scala , et c'est l'exemple «Comment configurer Scala» . scalafiddle.net est une bonne ressource pour l'exécution de petits exemples de code sur le Web.

Versions

Version Date de sortie
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

Bonjour le monde en script

Scala peut être utilisé comme langage de script. Pour illustrer, créez HelloWorld.scala avec le contenu suivant:

println("Hello")
 

Exécutez-le avec l'interpréteur de ligne de commande (le $ est l'invite de la ligne de commande):

$ scala HelloWorld.scala
Hello
 

Si vous omettez .scala (comme si vous aviez simplement tapé scala HelloWorld ), le coureur recherchera un fichier .class compilé avec bytecode au lieu de compiler, puis d'exécuter le script.

Remarque: Si scala est utilisé comme langage de script, aucun package ne peut être défini.

Dans les systèmes d'exploitation utilisant des terminaux shell bash ou similaires, les scripts Scala peuvent être exécutés à l'aide d'un «préambule de shell». Créez un fichier nommé HelloWorld.sh et placez-le comme contenu:

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

Les parties entre #! et !# est le préambule du shell et est interprété comme un script bash. Le reste est Scala.

Une fois que vous avez enregistré le fichier ci-dessus, vous devez lui accorder des autorisations «exécutables». Dans le shell, vous pouvez faire ceci:

$ chmod a+x HelloWorld.sh
 

(Notez que cela donne la permission à tout le monde: lisez à propos de chmod pour savoir comment le définir pour des ensembles d'utilisateurs plus spécifiques.)

Maintenant, vous pouvez exécuter le script comme ceci:

$ ./HelloWorld.sh
 

Bonjour tout le monde en définissant une méthode 'principale'

Placez ce code dans un fichier nommé HelloWorld.scala :

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

Démo en direct

Pour le compiler en bytecode qui est exécutable par la JVM:

$ scalac HelloWorld.scala
 

Pour l'exécuter:

$ scala Hello
 

Lorsque le runtime Scala charge le programme, il recherche un objet nommé Hello avec une méthode main . La méthode main est le point d’entrée du programme et est exécutée.

Notez que, contrairement à Java, Scala n'a pas besoin de nommer des objets ou des classes après le fichier dans lequel ils se trouvent. Au lieu de cela, le paramètre Hello transmis dans la commande scala Hello fait référence à l'objet à rechercher contenant la méthode main à exécuter. Il est parfaitement possible d'avoir plusieurs objets avec des méthodes principales dans le même fichier .scala .

Le tableau args contiendra les arguments de ligne de commande donnés au programme, le cas échéant. Par exemple, nous pouvons modifier le programme comme ceci:

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

Compilez-le:

$ scalac HelloWorld.scala
 

Et ensuite l'exécuter:

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

Bonjour tout le monde en étendant l'application

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

Démo en direct

En étendant le trait App , vous pouvez éviter de définir une méthode main explicite. Le corps entier de l'objet HelloWorld est traité comme "la méthode principale".

2.11.0

Initialisation différée

Selon la documentation officielle , App utilise une fonctionnalité appelée Initialisation différée . Cela signifie que les champs d'objet sont initialisés après l'appel de la méthode principale.

2.11.0

Initialisation différée

Selon la documentation officielle , App utilise une fonctionnalité appelée Initialisation différée . Cela signifie que les champs d'objet sont initialisés après l'appel de la méthode principale.

DelayedInit est maintenant obsolète pour un usage général, mais est toujours pris en charge pour App tant que cas particulier. Le support continuera jusqu'à ce qu'une fonctionnalité de remplacement soit décidée et implémentée.

Pour accéder aux arguments de ligne de commande lors de l'extension de l' App , utilisez this.args :

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

Lorsque vous utilisez App , le corps de l'objet sera exécuté en tant que méthode main , il n'est pas nécessaire de remplacer le main .

Scala Quicksheet

La description Code
Attribuer une valeur int immuable val x = 3
Attribuer une valeur intable mutable var x = 3
Attribuer une valeur immuable avec un type explicite val x: Int = 27
Attribuer une valeur évaluée paresseuse lazy val y = print("Sleeping in.")
Lier une fonction à un nom val f = (x: Int) => x * x
Lier une fonction à un nom de type explicite val f: Int => Int = (x: Int) => x * x
Définir une méthode def f(x: Int) = x * x
Définir une méthode avec typage explicite def f(x: Int): Int = x * x
Définir une classe class Hopper(someParam: Int) { ... }
Définir un objet object Hopper(someParam: Int) { ... }
Définir un trait trait Grace { ... }
Obtenir le premier élément de la séquence Seq(1,2,3).head
Si interrupteur val result = if(x > 0) "Positive!"
Obtenez tous les éléments de la séquence sauf le premier Seq(1,2,3).tail
Boucle à travers une liste for { x <- Seq(1,2,3) } print(x)
Boucle imbriquée for {
x <- Seq(1,2,3)
y <- Seq(4,5,6)
} print(x + ":" + y)
Pour chaque fonction d'exécution de l'élément de liste List(1,2,3).foreach { println }
Imprimer en standard print("Ada Lovelace")
Trier une liste de manière alphanumérique List('b','c','a').sorted

Utiliser la Scala REPL

Lorsque vous exécutez scala dans un terminal sans paramètres supplémentaires, il ouvre un interpréteur 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> 
 

Le REPL vous permet d'exécuter Scala selon une feuille de calcul: le contexte d'exécution est préservé et vous pouvez essayer manuellement les commandes sans avoir à créer un programme complet. Par exemple, en tapant val poem = "As halcyons we shall be" cela ressemblerait à ceci:

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

Maintenant, nous pouvons imprimer notre val :

scala> print(poem)
As halcyons we shall be
 

Notez que val est immuable et ne peut être écrasé:

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

Mais dans le REPL, vous pouvez redéfinir un val (ce qui provoquerait une erreur dans un programme Scala normal, si cela était fait dans le même domaine):

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

Pour le reste de votre session REPL, cette variable nouvellement définie suivra la variable précédemment définie. Les REPL sont utiles pour voir rapidement le fonctionnement des objets ou du code. Toutes les fonctionnalités de Scala sont disponibles: vous pouvez définir des fonctions, des classes, des méthodes, etc.