Avec égal signe:
object HelloWorld { def main(args: Array[Ssortingng]) = { println("Hello!") } }
Sans égal signe:
object HelloWorld { def main(args: Array[Ssortingng]) { println("Hello!") } }
Les deux programmes ci-dessus s’exécutent de la même manière. Dans le billet de blog Choses que je n’aime pas dans Scala J’ai lu que lorsque le signe égal est manquant, la méthode retournera Unit
(identique au void
de Java), donc les méthodes qui renvoient une valeur doivent utiliser le signe égal. Mais les méthodes qui ne renvoient pas de valeur peuvent être écrites dans les deux cas.
Quelle est la meilleure pratique pour utiliser les méthodes Scala à signe égal qui ne renvoient pas de valeur?
En fait, je ne suis pas du tout d’accord avec Daniel. Je pense que la syntaxe non égale ne devrait jamais être utilisée. Si votre méthode est exposée en tant qu’API et que vous craignez de renvoyer accidentellement le mauvais type, ajoutez une annotation de type explicite:
object HelloWorld { def main(args: Array[Ssortingng]): Unit = { println("Hello!") 123 } }
La syntaxe non égale est plus courte et peut paraître “plus propre”, mais je pense que cela ajoute simplement une possibilité de confusion. J’ai parfois oublié d’append un signe égal et je pensais que ma méthode renvoyait une valeur alors qu’elle retournait en réalité l’Unité. Parce que les syntaxes de type non égal et égal avec le type inféré sont si visuellement similaires, il est facile de passer à côté de ce problème.
Même si cela me coûte un peu plus de travail, je préfère les annotations de type explicites quand elles sont importantes (à savoir, les interfaces exposées).
UPDATE: à partir de Scala-2.10, utiliser le signe égal est préférable. Vieille réponse:
Les méthodes qui renvoient Unit
doivent toujours utiliser la syntaxe non égale. Cela évite les erreurs potentielles dans la mise en œuvre transférées dans l’API. Par exemple, vous pourriez avoir accidentellement fait quelque chose comme ceci:
object HelloWorld { def main(args: Array[Ssortingng]) = { println("Hello!") 123 } }
Exemple sortingvial bien sûr, mais vous pouvez voir comment cela pourrait être un problème. Comme la dernière expression ne retourne pas Unit
, la méthode elle-même aura un type de retour autre que Unit
. Ceci est exposé dans l’API publique et peut entraîner d’autres problèmes ultérieurement. Avec la syntaxe non égale, peu importe la dernière expression, Scala corrige le type de retour en tant Unit
.
C’est aussi deux personnages plus propres. 🙂 J’ai aussi tendance à penser que la syntaxe non égale rend le code un peu plus facile à lire. Il est plus évident que la méthode en question renvoie l’ Unit
plutôt qu’une valeur utile.
Sur une note connexe, il existe une syntaxe analogue pour les méthodes abstraites:
trait Foo { def bar(s: Ssortingng) }
La bar
méthode a la signature Ssortingng=>Unit
. Scala le fait lorsque vous omettez l’annotation de type sur un membre abstrait. Encore une fois, c’est plus propre et (je pense) plus facile à lire.
Vous devez utiliser les déclarations d’appels d’égal à égal sauf les définitions renvoyant l’unité.
Dans ce dernier cas, vous pouvez renoncer au signe égal. Cette syntaxe est peut-être obsolète, alors il vaut mieux l’éviter. L’utilisation du signe égal et la déclaration du type de retour fonctionneront toujours.
Pour les méthodes, Scala Style Guide recommande la syntaxe égale par opposition à la syntaxe de procédure
Syntaxe de procédure
Évitez la syntaxe de la procédure, car elle a tendance à être source de confusion pour un gain de concision très limité.
// don't do this def printBar(bar: Baz) { println(bar) } // write this instead def printBar(bar: Bar): Unit = { println(bar) }
Une chose: imaginez la dernière instruction d’une méthode qui devrait retourner Unit ne renvoie pas Unit. Utiliser la syntaxe non égale est alors très pratique, j’espère que cela ne sera pas déconseillé car je vois plusieurs cas d’utilisation pour cela
Au fil du temps, le style par défaut a changé et cela a été mentionné dans de nombreux commentaires, il est recommandé dans le guide de style officiel d’utiliser la syntaxe =
pour les déclarations de fonction.
pour les méthodes qui n’ont pas de valeur de retour, une manière d’exprimer ces méthodes est de laisser de côté le type de résultat et le signe égal, en suivant la méthode avec un bloc entre accolades. Dans cette forme, la méthode ressemble à une procédure, une méthode qui est exécutée uniquement pour ses effets secondaires.