--- language: Scala filename: learnscala.scala contributors: - ["George Petrov", "http://github.com/petrovg"] - ["Dominic Bou-Samra", "http://dbousamra.github.com"] translators: - ["Anne-Catherine Dehier", "https://github.com/spellart"] filename: learn.scala lang: fr-fr --- ### Scala - le langage évolutif ```scala /* Pour vous préparer : 1) (Téléchargez Scala)[http://www.scala-lang.org/downloads] 2) Dézippez/décompressez dans votre endroit préféré et ajoutez le chemin du sous-répertoire bin au chemin du système 3) Commencez un REPL de Scala en tapant juste scala. Vous devriez voir le prompteur : scala> C'est ce qu'on appelle un REPL (Read-Eval-Print-Loop), c'est une interface de programmation interactive. Vous pouvez y exécuter des commandes. Allons-y : */ println(10) // affiche l'integer 10 println("Boo!") // affiche avec retour à la ligne la chaîne de caractère Boo! // Quelques basiques // Imprimer et forcer une nouvelle ligne à la prochaine impression println("Hello world!") // Imprimer sans forcer une nouvelle ligne à la prochaine impression print("Hello world") // Pour déclarer des valeurs on utilise var ou val // Les déclarations val sont immuables, tandis que les var sont muables. // L'immuabilité est une bonne chose. val x = 10 // x vaut maintenant 10 x = 20 // erreur : réaffectation à val var x = 10 x = 20 // x vaut maintenant 20 // Les commentaires d'une ligne commencent par deux slashs /* Les commentaires multilignes ressemblent à ça. */ // les valeurs booléennes true false // Les opérateurs booléens !true // false !false // true true == false // false 10 > 5 // true // Les opérateurs mathématiques sont habituels 1 + 1 // 2 2 - 1 // 1 5 * 3 // 15 6 / 2 // 3 // Le REPL donne le type et la valeur du résultat quand vous évaluez une commande 1 + 7 /* Les lignes ci-dessous donnent les résultats : scala> 1 + 7 res29: Int = 8 Ça signifie que le résultat de l'évaluation 1 + 7 est un objet de type Int avec une valeur de 8 1+7 donnera le même résultat */ // Tout est un objet, même une fonction. Tapez ceci dans le REPL : 7 // donne res30: Int = 7 (res30 est seulement un nom de variable généré pour le résultat) // La ligne suivante est une fonction qui prend un Int et retourne son carré (x:Int) => x * x // On peut assigner cette fonction à un identifieur comme ceci : val sq = (x:Int) => x * x /* La ligne suivante nous dit : sq: Int => Int = Ce qui signifie que cette fois-ci nous avons donné un nom explicite à la valeur. sq est une fonction qui prend un Int et retourne un Int. sq peut être exécutée comme ci-dessous : */ sq(10) // donne comme résultat : res33: Int = 100. // les deux-points définissent explicitement le type de la valeur, // dans ce cas une fonction qui prend un Int et retourne un Int. val add10: Int => Int = _ + 10 // Scala autorise des méthodes et des fonctions à retourner // ou prendre comme paramètres des autres fonctions ou méthodes List(1, 2, 3) map add10 // List(11, 12, 13) - add10 est appliqué à chaque éléments // Les fonctions anonymes peuvent être utilisées à la place des fonctions nommées : List(1, 2, 3) map (x => x + 10) // Le tiret du bas peut être utilisé si la fonction anonyme ne prend qu'un paramètre. // Il se comporte comme une variable List(1, 2, 3) map (_ + 10) // Si le bloc et la fonction anonyme prennent tous les deux un seul argument, // vous pouvez omettre le tiret du bas List("Dom", "Bob", "Natalia") foreach println // Les structures de données val a = Array(1, 2, 3, 5, 8, 13) a(0) a(3) a(21) // Lance une exception val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo") m("fork") m("spoon") m("bottle") // Lance une exception val safeM = m.withDefaultValue("no lo se") safeM("bottle") val s = Set(1, 3, 7) s(0) s(1) /* Jetez un oeil sur la documentation de map ici - * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map */ // Tuples (1, 2) (4, 3, 2) (1, 2, "three") (a, 2, "three") // Exemple d'utilisation val divideInts = (x:Int, y:Int) => (x / y, x % y) divideInts(10,3) // La fonction divideInts donne le résultat et le reste de la division // Pour accéder à un élément d'un tuple, utilisez _._n // où n est l'index de base 1 de l'élément val d = divideInts(10,3) d._1 d._2 // Des combinaisons s.map(sq) val sSquared = s. map(sq) sSquared.filter(_ < 10) sSquared.reduce (_+_) // La fonction filter prend un prédicat (une fonction de type A -> Booléen) et // sélectionne tous les éléments qui satisfont ce prédicat List(1, 2, 3) filter (_ > 2) // List(3) List( Person(name = "Dom", age = 23), Person(name = "Bob", age = 30) ).filter(_.age > 25) // List(Person("Bob", 30)) // Scala a une méthode foreach définie pour certaines collections // qui prend en argument une fonction renvoyant Unit (une méthode void) aListOfNumbers foreach (x => println(x)) aListOfNumbers foreach println // Compréhensions de listes for { n <- s } yield sq(n) val nSquared2 = for { n <- s } yield sq(n) for { n <- nSquared2 if n < 10 } yield n for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared /* Les exemples précédents ne sont pas des boucles for. La sémantique des boucles for est "répète", alors qu'une for-compréhension définit une relation entre deux ensembles de données. */ // Boucles et itération 1 to 5 val r = 1 to 5 r.foreach( println ) r foreach println // NB: Scala est vraiment tolérant par rapport aux points et aux parenthèses en étudiant les roles séparément. // Ça aide pour écrire des DSL ou des API qui se lisent comme en anglais. (5 to 1 by -1) foreach ( println ) // Une boucle while var i = 0 while (i < 10) { println("i " + i); i+=1 } while (i < 10) { println("i " + i); i+=1 } // Oui, encore. Qu'est-ce qui s'est passé ? Pourquoi ? i // Montre la valeur de i. Notez que while est une boucle au sens classique. // Il exécute séquentiellement pendant que la variable de boucle change. // While est très rapide, // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus // facile pour comprendre et pour faire la parallélisation // La boucle do while do { println("x is still less then 10"); x += 1 } while (x < 10) // La récursivité est un moyen idiomatique de faire une chose répétitive en Scala. // Les fonctions récursives ont besoin d'un type de retour explicite, // le compilateur ne peut pas le déduire. // Ici c'est Unit. def showNumbersInRange(a:Int, b:Int):Unit = { print(a) if (a < b) showNumbersInRange(a + 1, b) } // Structures de contrôle val x = 10 if (x == 1) println("yeah") if (x == 10) println("yeah") if (x == 11) println("yeah") if (x == 11) println ("yeah") else println("nay") println(if (x == 10) "yeah" else "nope") val text = if (x == 10) "yeah" else "nope" var i = 0 while (i < 10) { println("i " + i); i+=1 } // Les caractéristiques "Orienté Objet" // Création d'une classe Dog class Dog { // Une méthode appelée bark qui retourne une chaîne de caractère def bark: String = { // le corps de la méthode "Woof, woof!" } } // Les classes peuvent contenir presque n'importe quelle autre construction, incluant d'autres classes, // des fonctions, des méthodes, des objets, des classes case, des traits, etc ... // Les classes case case class Person(name:String, phoneNumber:String) Person("George", "1234") == Person("Kate", "1236") // Correspondances de motifs val me = Person("George", "1234") me match { case Person(name, number) => { "We matched someone : " + name + ", phone : " + number }} me match { case Person(name, number) => "Match : " + name; case _ => "Hm..." } me match { case Person("George", number) => "Match"; case _ => "Hm..." } me match { case Person("Kate", number) => "Match"; case _ => "Hm..." } me match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" } val kate = Person("Kate", "1234") kate match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" } // Expressions régulières val email = "(.*)@(.*)".r // On fait une Regex en invoquant r sur la chaîne de caractère val email(user, domain) = "henry@zkpr.com" "mrbean@pyahoo.com" match { case email(name, domain) => "I know your name, " + name } // Les chaînes de caractères "Les chaînes de caractères Scala sont entourées de doubles guillements" 'a' // Un caractère de Scala 'Les simples guillemets n'existent pas en Scala // Erreur "Les chaînes de caractères possèdent les méthodes usuelles de Java".length "Il y a aussi quelques méthodes extra de Scala.".reverse // Voir également : scala.collection.immutable.StringOps println("ABCDEF".length) println("ABCDEF".substring(2, 6)) println("ABCDEF".replace("C", "3")) val n = 45 println(s"We have $n apples") val a = Array(11, 9, 6) println(s"My second daughter is ${a(2-1)} years old") // Certains caractères ont besoin d'être "échappés", // ex un guillemet à l'intérieur d'une chaîne de caractères : val a = "They stood outside the \"Rose and Crown\"" // Les triples guillemets permettent d'écrire des chaînes de caractères // sur plusieurs lignes et peuvent contenir des guillemets val html = """

Press belo', Joe

|
""" // Structure et organisation d'une application // Importer des chaînes de caratères import scala.collection.immutable.List // Importer tous les sous-paquets import scala.collection.immutable._ // Importer plusieurs classes en une seule instruction import scala.collection.immutable.{List, Map} // Renommer un import en utilisant '=>' import scala.collection.immutable.{ List => ImmutableList } // Importer toutes les classes, à l'exception de certaines. // La ligne suivante exclut Map et Set : import scala.collection.immutable.{Map => _, Set => _, _} // Le point d'entrée du programme est défini dans un fichier scala // utilisant un objet, avec une simple méthode main : object Application { def main(args: Array[String]): Unit = { // Votre code ici. } } // Les fichiers peuvent contenir plusieurs classes et plusieurs objets. // On les compile avec scalac // Entrée et Sortie // Pour lire un fichier ligne par ligne import scala.io.Source for(line <- Source.fromFile("myfile.txt").getLines()) println(line) // On utilise le PrintWriter de Java pour écrire un fichier ``` ## Autres ressources [Scala for the impatient](http://horstmann.com/scala/) [Twitter Scala school](http://twitter.github.io/scala_school/) [The scala documentation](http://docs.scala-lang.org/) [Try Scala in your browser](http://scalatutorials.com/tour/) Rejoindre le [Scala user group](https://groups.google.com/forum/#!forum/scala-user)