Envoyé par
_skip
Scala plutôt que java, feriez-vous le saut ?
J'avais déjà entendu parler de Scala et regardé un peu à quoi ça ressemblait. Maintenant je me rappelle pour quoi je n'ai pas fait le saut :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
| // Java:
public class Point {
private double x, y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public double x() {
return x;
}
public double y() {
return y;
}
public Point(double x, double y, boolean addToGrid) {
this(x, y);
if (addToGrid)
grid.add(this);
}
public Point() {
this(0.0, 0.0);
}
double distanceToPoint(Point other) {
return distanceBetweenPoints(x, y,
other.x, other.y);
}
private static Grid grid = new Grid();
static double distanceBetweenPoints(
double x1, double y1,
double x2, double y2
) {
double xdist = x1 - x2;
double ydist = y1 - y2;
return Math.sqrt(xdist * xdist + ydist * ydist);
}
} |
et la même en Scala:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
// Scala
class Point(
// adding `val` here automatically creates
// public accessor methods named `x` and `y`
val x: Double, val y: Double,
addToGrid: Boolean = false
) {
// import functions/vars from companion object
import Point._
if (addToGrid)
grid.add(this)
def this() {
this(0.0, 0.0)
}
def distanceToPoint(other: Point) =
distanceBetweenPoints(x, y, other.x, other.y)
}
object Point {
// private/protected members shared between
// class and companion object
private val grid = new Grid()
def distanceBetweenPoints(x1: Double, y1: Double,
x2: Double, y2: Double) = {
val xdist = x1 - x2
val ydist = y1 - y2
math.sqrt(xdist * xdist + ydist * ydist)
}
} |
Source:
wikipedia.
Ok c'est plus court en Scala (d'environ 25%) mais je trouve ça vraiment moins lisible.
Evidemment, c'est une question d'habitude et il faudrait commencer par maitriser le comportement de compilation spécifique à Scala (comme la création automatique des getters ou setters), mais je trouve que le code est tout de même moins explicite (normal, moins verbeux me direz vous) avec des redondances un peu bizarres comme cette histoire d'
object et de
class Point. Et le coup du
if (addToGrid) paumé tout seul (ie., pas dans une méthode), ça m'a bien embrouillé. ^^
Bref, ça m'attire pas trop comme langage. D'autant plus que le code produit aura les même perfos (ou similaire) que si ça avait été code en Java. Donc non, quitte à devoir réapprendre un langage, autant en choisir un vraiment différent (python, C++, Lisp
).
Ca reviendrait un peu à apprendre VB.NET ou Eiffel# alors qu'on est déjà un développeur confirmé en C# : aucun intérêt...
1 |
3 |
Typesafe obtient 14M de $ pour mettre en avant Scala
