Quelle est la règle pour la parenthèse dans l'invocation de la méthode Scala?
ToList n'est-il pas une méthode qui convertit quelque chose en une liste?
Si oui, pourquoi ne puis-je pas utiliser la parenthèse avec? Je dois manquer quelque chose de plus fondamental ici.
Voici l'exemple:
val l = Array(1,2,3).toList // works fine
val l = Array(1,2,3).toList() // gives the error below
Pas assez d'arguments pour la méthode s'appliquent: (n: Int)Int trait LinearSeqOptimized. Paramètre de valeur non spécifié n.
3 réponses
, Si une méthode est définie comme
def toList = { /* something */ }
, Alors il doit être appelé comme
object.toList
Sans parenthèses supplémentaires. Nous disons que cette méthode a zéro listes de paramètres .
Nous pourrions aussi définir une liste de paramètres mais n'y mettre rien:
def toList() = { /* something */ }
Maintenant, nous pourrions appeler l'un des
object.toList()
object.toList
Depuis Scala permet le raccourci d'omettre les parenthèses sur les appels de méthode.
En ce qui concerne la JVM, il n'y a pas de différence entre la première définition ("listes de paramètres zéro") et la seconde ("une liste de paramètres vide"). Mais Scala maintient une distinction. Que ce soit une bonne idée ou non est discutable, mais la motivation pourrait être plus claire quand vous réalisez que nous pouvons aussi
def toList()() = { /* something */ }
Qui est connu comme deux listes de paramètres vides , puis appelez l'un des
object.toList()()
object.toList()
object.toList
Et maintenant, si nous devions convertir cela en une fonction, nous le taperions comme
() => () => T /* T is the return value of the something */
Alors que la deuxième définition soit
() => T
Qui est clairement différent conceptuellement, même si pratiquement vous l'utilisez de la même manière (ne rien mettre et tôt ou tard sortir un T).
Quoi qu'il en soit, toList n'a pas besoin de paramètres, et la norme Scala est de laisser les parens à moins que la méthode ne modifie l'objet lui-même (plutôt que de simplement renvoyer quelque chose), donc c'est def toList sans parens par la suite. Et ainsi vous ne pouvez l'appeler que object.toList.
Votre deuxième ligne est en fait interprétée comme
val l = Array(1,2,3).toList.apply()
Puisque foo(x) est la syntaxe "magique" pour foo.apply(x).
C'est pourquoi le compilateur se plaint de "pas assez d'arguments", car la méthode apply sur les listes prend un argument.
Ainsi, vous pouvez écrire par exemple:
scala> val i = Array(1, 2, 3).toList(1)
i: Int = 2
Laissez-moi répondre du point de vue du style de codage Scala.
Scala Guide de style dit...
Omettez les parenthèses vides, ne soyez utilisé que lorsque la méthode en question n'a pas d'effets secondaires (purement fonctionnels). En d'autres termes, il serait possible d'omettre les parenthèses lors de l'appel de la file d'attente.taille, mais pas lors de l'appel de println ().
L'observation religieuse de cette convention améliorera considérablement la lisibilité du code et le rendra beaucoup plus facile à comprendre en un coup d'œil fonctionnement de base d'une méthode donnée. Résistez à l'envie d'omettre les parenthèses simplement pour sauver deux caractères!