From 664389fb7c17a8c7271b32270f51b38a85f75bdd Mon Sep 17 00:00:00 2001 From: chtiprog Date: Tue, 10 Jun 2014 17:52:36 +0200 Subject: Added french version of Scala --- fr-fr/scala.html.markdown | 456 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 456 insertions(+) create mode 100644 fr-fr/scala.html.markdown (limited to 'fr-fr') diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown new file mode 100644 index 00000000..56ecfb0b --- /dev/null +++ b/fr-fr/scala.html.markdown @@ -0,0 +1,456 @@ +--- +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. Vous pouvez y exécuter des commandes. + Allons-y : +*/ + +println(10) // imprime l'integer 10 + +println("Boo!") // imprime 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 utile 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 maths sont comme d'habitude +1 + 1 // 2 +2 - 1 // 1 +5 * 3 // 15 +6 / 2 // 3 + + +// REPL donne le type et la valeur du résultat quand vous évaluez une commande + +1 + 7 + +/* Les lignes ci-dessous donne 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 var 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é comme ci-dessous : +*/ + +sq(10) // donne comme résultat : res33: Int = 100. + + +// les deux-points définissent explicitement le type de 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 pour 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 il n'y a qu'un paramètre à la fonction anonyme. +// Il se borne à 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) // Jette une exception + +val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo") +m("fork") +m("spoon") +m("bottle") // Jette 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") + +// Pourquoi avoir ça ? +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 prends un prédicat (une fonction de 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 un type d'argument retournant Unit (une méthode void) +aListOfNumbers foreach (x => println(x)) +aListOfNumbers foreach println + + + + +// For compréhensions + +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 + + + +/* Ci-dessus ce 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, plus rapide que les boucles Java, + // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus + // facile pour comprendre et faire le parallèle + +// 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écurrente 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) +} + + + +// Conditionnelles + +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ées objets + +// Classname is 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 quel autre constructeur, 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 un 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 double guillement à l'intérieur d'une chaîne de caractère : +val a = "They stood outside the \"Rose and Crown\"" + +// Les triples doubles guillemets permettent d'écrire des chaînes de caractères +// sur plusieurs lignes et peuvent contenir des guillements + +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 des classes multiples 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 quelques unes. +// Les suivantes excluant 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 = { + // stuff goes here. + } +} + +// Les fichiers peuvent contenir des classes multiples et des objets. +// On les compile avec scalac + + + + +// Entrée et Sortie + +// Pour lire un fichier lignes par lignes +import scala.io.Source +for(line <- Source.fromFile("myfile.txt").getLines()) + println(line) + +// On utilise Java's PrintWriter 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) -- cgit v1.2.3 From f011c1af0e84570e567d07e48904b579b8b58a1f Mon Sep 17 00:00:00 2001 From: chtiprog Date: Tue, 10 Jun 2014 23:12:07 +0200 Subject: Updated french version of scala --- fr-fr/scala.html.markdown | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown index 56ecfb0b..dfcdf7cc 100644 --- a/fr-fr/scala.html.markdown +++ b/fr-fr/scala.html.markdown @@ -148,12 +148,12 @@ List("Dom", "Bob", "Natalia") foreach println val a = Array(1, 2, 3, 5, 8, 13) a(0) a(3) -a(21) // Jette une exception +a(21) // Lance une exception val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo") m("fork") m("spoon") -m("bottle") // Jette une exception +m("bottle") // Lance une exception val safeM = m.withDefaultValue("no lo se") safeM("bottle") @@ -183,7 +183,7 @@ 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 +// 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) @@ -233,7 +233,7 @@ for { n <- nSquared2 if n < 10 } yield n for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared - + /* Ci-dessus ce 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. */ @@ -265,9 +265,9 @@ while (i < 10) { println("i " + i); i+=1 } // Oui, encore. Qu'est-ce qui s'es 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, plus rapide que les boucles Java, - // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus + // Il exécute séquentiellement pendant que la variable de boucle change. + // While est très rapide, plus rapide que les boucles Java, + // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus // facile pour comprendre et faire le parallèle // La boucle do while @@ -278,8 +278,8 @@ do { // La récursivité est un moyen idiomatique de faire une chose récurrente en Scala. -// Les fonctions récursives ont besoin d'un type de retour explicite, -// le compilateur ne peut pas le déduire. +// 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) @@ -355,7 +355,7 @@ kate match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" // Expressions régulières -val email = "(.*)@(.*)".r // On fait un Regex en invoquant r sur la chaîne de caractère +val email = "(.*)@(.*)".r // On fait un Regex en invoquant r sur la chaîne de caractère val email(user, domain) = "henry@zkpr.com" @@ -370,8 +370,8 @@ val email(user, domain) = "henry@zkpr.com" "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 +"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 @@ -385,7 +385,7 @@ 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", +// Certains caractères ont besoin d'être "échappés", // ex un double guillement à l'intérieur d'une chaîne de caractère : val a = "They stood outside the \"Rose and Crown\"" @@ -410,14 +410,14 @@ import scala.collection.immutable._ // Importer des classes multiples en une seule instruction import scala.collection.immutable.{List, Map} -// Renommer un import en utilisant '=>' +// Renommer un import en utilisant '=>' import scala.collection.immutable.{ List => ImmutableList } -// Importer toutes les classes, à l'exception de quelques unes. +// Importer toutes les classes, à l'exception de quelques unes. // Les suivantes excluant Map et Set : import scala.collection.immutable.{Map => _, Set => _, _} -// Le point d'entrée du programme est défini dans un fichier scala +// 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 = { @@ -425,7 +425,7 @@ object Application { } } -// Les fichiers peuvent contenir des classes multiples et des objets. +// Les fichiers peuvent contenir des classes multiples et des objets. // On les compile avec scalac -- cgit v1.2.3 From 57cc424b54736287f911777f8b9615882647374d Mon Sep 17 00:00:00 2001 From: chtiprog Date: Sat, 14 Jun 2014 13:04:18 +0200 Subject: Corrections after pull request of the french translation of Scala --- fr-fr/scala.html.markdown | 96 ++++++++++++++++++++++++----------------------- 1 file changed, 49 insertions(+), 47 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown index dfcdf7cc..2e18d219 100644 --- a/fr-fr/scala.html.markdown +++ b/fr-fr/scala.html.markdown @@ -18,19 +18,20 @@ lang: fr-fr 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é + 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. Vous pouvez y exécuter des commandes. + 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) // imprime l'integer 10 +println(10) // affiche l'integer 10 -println("Boo!") // imprime avec retour à la ligne la chaîne de caractère Boo! +println("Boo!") // affiche avec retour à la ligne la chaîne de caractère Boo! // Quelques basiques @@ -40,14 +41,14 @@ println("Hello world!") // Imprimer sans forcer une nouvelle ligne à la prochaine impression print("Hello world") -// Pour déclarer des valeurs on utile var ou val +// 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 +x = 20 // erreur : réaffectation à val var x = 10 -x = 20 // x vaut maintenant 20 +x = 20 // x vaut maintenant 20 // Les commentaires d'une ligne commencent par deux slashs @@ -65,18 +66,18 @@ false true == false // false 10 > 5 // true -// Les maths sont comme d'habitude +// Les opérateurs mathématiques sont habituels 1 + 1 // 2 2 - 1 // 1 5 * 3 // 15 6 / 2 // 3 -// REPL donne le type et la valeur du résultat quand vous évaluez une commande +// Le REPL donne le type et la valeur du résultat quand vous évaluez une commande 1 + 7 -/* Les lignes ci-dessous donne les résultats : +/* Les lignes ci-dessous donnent les résultats : scala> 1 + 7 res29: Int = 8 @@ -90,7 +91,7 @@ true == false // false // Tout est un objet, même une fonction. Tapez ceci dans le REPL : -7 // donne res30: Int = 7 (res30 est seulement un nom de var généré pour le résultat) +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é @@ -104,22 +105,22 @@ val sq = (x:Int) => x * x sq: Int => Int = - Ce qui signifie que cette fois-ci nous avons donné un nom explicite à la valeur + 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é comme ci-dessous : + sq peut être exécutée comme ci-dessous : */ -sq(10) // donne comme résultat : res33: Int = 100. +sq(10) // donne comme résultat : res33: Int = 100. -// les deux-points définissent explicitement le type de valeur, +// 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 pour retourner, -// ou prendre comme paramètres, des autres fonctions ou méthodes +// 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 @@ -131,8 +132,8 @@ List(1, 2, 3) map (x => x + 10) -// Le tiret du bas peut être utilisé si il n'y a qu'un paramètre à la fonction anonyme. -// Il se borne à une variable +// 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) @@ -177,7 +178,7 @@ s(1) (a, 2, "three") -// Pourquoi avoir ça ? +// Exemple d'utilisation val divideInts = (x:Int, y:Int) => (x / y, x % y) @@ -205,7 +206,7 @@ sSquared.reduce (_+_) -// La fonction filter prends un prédicat (une fonction de A -> Booléen) et +// 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( @@ -216,14 +217,14 @@ List( // Scala a une méthode foreach définie pour certaines collections -// qui prend un type d'argument retournant Unit (une méthode void) +// qui prend en argument une fonction renvoyant Unit (une méthode void) aListOfNumbers foreach (x => println(x)) aListOfNumbers foreach println -// For compréhensions +// Compréhensions de listes for { n <- s } yield sq(n) @@ -235,8 +236,9 @@ for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared -/* Ci-dessus ce 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. */ +/* 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. */ @@ -247,8 +249,8 @@ 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 +// 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 ) @@ -277,7 +279,7 @@ do { } while (x < 10) -// La récursivité est un moyen idiomatique de faire une chose récurrente en Scala. +// 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. @@ -289,7 +291,7 @@ def showNumbersInRange(a:Int, b:Int):Unit = { -// Conditionnelles +// Structures de contrôle val x = 10 @@ -306,9 +308,9 @@ while (i < 10) { println("i " + i); i+=1 } -// Les caractéristiques orientées objets +// Les caractéristiques "Orienté Objet" -// Classname is Dog +// 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 = { @@ -318,7 +320,7 @@ class Dog { } -// Les classes peuvent contenir presque n'importe quel autre constructeur, incluant d'autres classes, +// 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 ... @@ -355,7 +357,7 @@ kate match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" // Expressions régulières -val email = "(.*)@(.*)".r // On fait un Regex en invoquant r sur la chaîne de caractère +val email = "(.*)@(.*)".r // On fait une Regex en invoquant r sur la chaîne de caractère val email(user, domain) = "henry@zkpr.com" @@ -367,13 +369,13 @@ val email(user, domain) = "henry@zkpr.com" // Les chaînes de caractères -"Les chaînes de caractères Scala sont entourées de doubles guillements" // +"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 +// Voir également : scala.collection.immutable.StringOps println("ABCDEF".length) println("ABCDEF".substring(2, 6)) @@ -386,11 +388,11 @@ 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 double guillement à l'intérieur d'une chaîne de caractère : +// ex un guillemet à l'intérieur d'une chaîne de caractères : val a = "They stood outside the \"Rose and Crown\"" -// Les triples doubles guillemets permettent d'écrire des chaînes de caractères -// sur plusieurs lignes et peuvent contenir des guillements +// 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

@@ -407,25 +409,25 @@ import scala.collection.immutable.List // Importer tous les sous-paquets import scala.collection.immutable._ -// Importer des classes multiples en une seule instruction +// 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 quelques unes. -// Les suivantes excluant Map et Set : +// 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 : +// utilisant un objet, avec une simple méthode main : object Application { def main(args: Array[String]): Unit = { - // stuff goes here. + // Votre code ici. } } -// Les fichiers peuvent contenir des classes multiples et des objets. +// Les fichiers peuvent contenir plusieurs classes et plusieurs objets. // On les compile avec scalac @@ -433,12 +435,12 @@ object Application { // Entrée et Sortie -// Pour lire un fichier lignes par lignes +// Pour lire un fichier ligne par ligne import scala.io.Source for(line <- Source.fromFile("myfile.txt").getLines()) println(line) -// On utilise Java's PrintWriter pour écrire un fichier +// On utilise le PrintWriter de Java pour écrire un fichier ``` @@ -453,4 +455,4 @@ for(line <- Source.fromFile("myfile.txt").getLines()) [Try Scala in your browser](http://scalatutorials.com/tour/) -Rejoindre le[Scala user group](https://groups.google.com/forum/#!forum/scala-user) +Rejoindre le [Scala user group](https://groups.google.com/forum/#!forum/scala-user) -- cgit v1.2.3 From ad9186f4f8389cb4cb23744a80bcf7bf47735869 Mon Sep 17 00:00:00 2001 From: chtiprog Date: Sat, 14 Jun 2014 19:26:14 +0200 Subject: Updated links and fix typo --- fr-fr/scala.html.markdown | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown index 2e18d219..46f602ff 100644 --- a/fr-fr/scala.html.markdown +++ b/fr-fr/scala.html.markdown @@ -17,14 +17,14 @@ lang: fr-fr /* Pour vous préparer : - 1) Téléchargez Scala - http://www.scala-lang.org/downloads + 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. + 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 : */ @@ -237,7 +237,7 @@ 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 + est "répète", alors qu'une for-compréhension définit une relation entre deux ensembles de données. */ @@ -249,7 +249,7 @@ 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. +// 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. @@ -270,7 +270,7 @@ 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, plus rapide que les boucles Java, // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus - // facile pour comprendre et faire le parallèle + // facile pour comprendre et faire la parallélisation // La boucle do while do { -- cgit v1.2.3 From 7c306cead86cbcfe56c0f5b112066260389b28ea Mon Sep 17 00:00:00 2001 From: chtiprog Date: Sat, 14 Jun 2014 19:37:45 +0200 Subject: Removing comparison with java performance for while loops --- fr-fr/scala.html.markdown | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'fr-fr') diff --git a/fr-fr/scala.html.markdown b/fr-fr/scala.html.markdown index 46f602ff..da562138 100644 --- a/fr-fr/scala.html.markdown +++ b/fr-fr/scala.html.markdown @@ -268,9 +268,9 @@ while (i < 10) { println("i " + i); i+=1 } // Oui, encore. Qu'est-ce qui s'es 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, plus rapide que les boucles Java, + // While est très rapide, // mais utiliser des combinateurs et des compréhensions comme ci-dessus est plus - // facile pour comprendre et faire la parallélisation + // facile pour comprendre et pour faire la parallélisation // La boucle do while do { -- cgit v1.2.3