Premiers pas avec le langage Scala

Hello World en étendant l’application 

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

[Démo en direct] (http://ideone.com/UgmX9y)

En étendant le App [trait][1], 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”.

Initialisation retardée

Selon la documentation officielle, App utilise une fonctionnalité appelée Delayed Initialization. Cela signifie que les champs de l’objet sont initialisés après l’appel de la méthode principale.

Initialisation retardée

Selon la documentation officielle, App utilise une fonctionnalité appelée [Delayed Initialization][ 2]. Cela signifie que les champs de l’objet sont initialisés après l’appel de la méthode principale.

DelayedInit est maintenant obsolète pour une utilisation générale, mais est toujours pris en charge pour App en tant que cas particulier. Le support continuera jusqu’à ce qu’une fonctionnalité de remplacement soit décidée et mise en œuvre.

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

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

Lors de l’utilisation de App, le corps de l’objet sera exécuté en tant que méthode main, il n’est pas nécessaire de remplacer main.

[1] : http://docs.scala-lang.org/tutorials/tour/traits.html [2] : http://www.scala-lang.org/api/current/#scala.DelayedInit

Hello World en définissant une méthode ‘main’

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 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 aucune obligation de nommer les objets ou les classes après le fichier dans lequel ils se trouvent. Au lieu de cela, le paramètre Hello passé dans la commande scala Hello fait référence à l’objet à rechercher qui contient le main méthode à 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 puis exécutez-le:

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

Hello World en tant que 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 ligne de commande) :

$ scala HelloWorld.scala
Hello

Si vous omettez .scala (comme si vous avez simplement tapé scala HelloWorld), le programme d’exécution recherchera un fichier .class compilé avec un 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 “bash” ou des terminaux shell similaires, les scripts Scala peuvent être exécutés à l’aide d’un “préambule shell”. Créez un fichier nommé “HelloWorld.sh” et placez ce qui suit comme contenu :

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

Les parties entre #! et !# constituent le ‘préambule du shell’ et sont interprétées 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][1] pour savoir comment le définir pour des ensembles d’utilisateurs plus spécifiques.)

Vous pouvez maintenant exécuter le script comme ceci :

$ ./HelloWorld.sh

[1] : https://en.wikipedia.org/wiki/Chmod

Fiche rapide Scala

Descriptif Codage
[Attribuer une valeur int immuable][1] val x = 3
[Attribuer une valeur int mutable][1] var x = 3
[Attribuer une valeur immuable avec un type explicite][1] val x : Entier = 27
[Attribuer une valeur évaluée paresseusement][2] lazy val y = print("Dormir.")
[Lier une fonction à un nom][1] val f = (x: Int) => x * x
[Lier une fonction à un nom avec un type explicite][1] val f : Int => Int = (x : Int) => x * x
[Définir une méthode][1] def f(x : entier) = x * x
[Définir une méthode avec un typage explicite][1] def f(x: Int): Int = x * x
[Définir une classe][3] class Hopper(someParam : Int) { ... }
[Définir un objet][3] object Hopper(someParam : Int) { ... }
[Définir un trait][4] trait Grace { ... }
[Obtenir le premier élément de la séquence][5] Seq(1,2,3).head
[Si commutateur][6] val result = if(x > 0) "Positive!"
[Obtenir tous les éléments de la séquence sauf le premier][5] Seq(1,2,3).tail
[Parcourir une liste][7] for { x <- Seq(1,2,3) } print(x)
[Boucle imbriquée][8] for {
  x <- Seq(1,2,3)
  y <- Seq(4,5,6)
} print( x + “:” + y)
[Pour chaque élément de la liste, exécutez la fonction][9] Liste(1,2,3).foreach { println }
Imprimer sur sortie standard print("Ada Lovelace")
[Trier une liste par ordre alphanumérique][10] Liste('b','c','a').sorted

[1] : https://www.wikiod.com/fr/scala/var-val-et-def#Var, Val et Def [2] : https://www.wikiod.com/fr/scala/var-val-et-def#Val paresseux [3] : https://www.wikiod.com/fr/scala/classes-et-objets#Objets singleton et compagnons [4] : https://www.wikiod.com/fr/scala/traits [5] : https://www.wikiod.com/fr/scala/collections [6] : https://www.wikiod.com/fr/scala/si-expressions#Expressions Si de base [7] : https://www.wikiod.com/fr/scala/pour-les-expressions [8] : https://www.wikiod.com/fr/scala/pour-les-expressions#Boucle For imbriquée [9] : https://www.wikiod.com/fr/scala/collections#Pour chaque [10] : https://www.wikiod.com/fr/scala/collections#Trier une liste

Utilisation du REPL Scala

Lorsque vous exécutez scala dans un terminal sans paramètres supplémentaires, cela ouvre un interpréteur [REPL][1] (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 à la manière d’une feuille de calcul : le contexte d’exécution est préservé et vous pouvez essayer manuellement des 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 pas être remplacé :

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, s’il était fait dans la même portée):

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 masquera la variable précédemment définie. Les REPL sont utiles pour voir rapidement comment fonctionnent les objets ou d’autres codes. Toutes les fonctionnalités de Scala sont disponibles : vous pouvez définir des fonctions, des classes, des méthodes, etc.

[1] : https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop

Correspondance de modèle →