La différence entre les méthodes et les fonctions Scala

Avant d'apprendre Scala, j'utilisais principalement Java et Python pour mon travail de développement quotidien. Dans mon souvenir, je ne distinguais pas délibérément les méthodes des fonctions. C'est comme le fait que nous ne distinguons pas délibérément la masse et le poids dans notre vie quotidienne. Cependant, elles sont bel et bien différentes, et ces différences reposent sur le lien entre elles !

Comment définir

Tout d’abord, référons-nous au texte anglais original pour voir les différences et les liens dans leurs définitions :

A Type de fonction est (en gros) un type de la forme (T1, ..., Tn) => U, qui est un raccourci pour le trait FunctionN dans la bibliothèque standard. Les fonctions anonymes et les valeurs de méthode ont des types de fonction, et les types de fonction peuvent être utilisés comme partie de déclarations et définitions de valeurs, variables et fonctions. En fait, il peut faire partie d’un type de méthode.

A Type de méthode est un type non-valeur. Cela signifie qu’il n’y a pas de valeur - aucun objet, aucune instance - avec un type de méthode. Comme mentionné ci-dessus, une Valeur de méthode a en fait un type de fonction. Un type de méthode est une def déclaration - tout ce qui concerne une def sauf son corps.

Exemple :

scala> def m1(x:Int) = x+3
m1: (x: Int)Int　　　　

scala> val f1 = (x: Int) => x+3
f1: Int => Int = <function1>

Vous voyez ? Les définitions des méthodes et des fonctions sont déjà montrées dans la signature du parseur Scala. `def m1(x: Int) = x+3` est une définition de méthode simple. Dans la signature, `m1: (x: Int)Int` indique que la méthode m1 a un paramètre Int x, et sa valeur de retour est Int.

`val f1 = (x: Int) => x+3` est une définition de fonction. Dans la signature du parseur, `f1: Int => Int = <function1>` indique que le corps de méthode de la fonction f1 accepte un paramètre Int, et le type du résultat de sortie est Int.

À partir de l’exemple ci-dessus, nous pouvons tirer une conclusion :

Une méthode est un bloc d’opérations logiques commençant par `def` et ayant une liste de paramètres (qui peut être absente), tout comme une méthode membre dans un objet ou une classe.

Une fonction est une méthode anonyme (avec ou sans liste de paramètres) affectée à une variable (ou constante), et est une expression qui utilise le symbole de conversion `=>` suivi d’un bloc de code logique. Le bloc de code logique après le symbole de conversion `=>` s’écrit de la même manière que le corps d’une méthode.

Autres différences

Une méthode peut apparaître comme partie d’une expression (appeler une fonction et passer des paramètres), mais une méthode (une méthode avec paramètres) ne peut pas être une expression finale. Une méthode sans paramètres le peut, mais cela devient un appel de méthode, car Scala permet d’omettre les parenthèses lors de l’appel d’une méthode sans argument. Une fonction peut apparaître comme expression finale.

scala> m1
<console>:12: error: missing arguments for method m1;
follow this method with `_' if you want to treat it as a partially applied function
       m1
       ^

scala> f1
res1: Int => Int = <function1>

Une méthode peut ne pas avoir de liste de paramètres, ou la liste de paramètres peut être vide. Cependant, une fonction doit avoir une liste de paramètres (qui peut aussi être vide). Un nom de méthode implique un appel de méthode, tandis qu’un nom de fonction représente simplement la fonction elle-même :

scala> def m2 = 100;
m2: Int

scala> def m3() = 1000;
m3: ()Int

scala> var f2 = => 100;
<console>:1: error: illegal start of simple expression
var f2 = => 100;
         ^

scala> var f2 =()=> 100;
f2: () => Int = <function0>

scala> m2
res2: Int = 100

scala> m3
res3: Int = 1000

scala> m3()
res4: Int = 1000

scala> f2
res5: () => Int = <function0>

scala> f2()
res6: Int = 100

Là où une fonction est attendue, nous pouvons fournir une méthode.

En effet, si nous fournissons une méthode là où une fonction est attendue, la méthode sera automatiquement convertie en fonction. Ce comportement est appelé expansion ETA.

Remarque :

Là où une fonction est attendue, nous pouvons utiliser une méthode.

Là où une fonction n’est pas attendue, une méthode ne sera pas automatiquement convertie en fonction.

En Scala, les opérateurs sont interprétés comme des méthodes :

Opérateur préfixe : `op obj` est interprété comme `obj.op`
Opérateur infixe : `obj1 op obj2` est interprété comme `obj1.op(obj2)`
Opérateur postfixe : `obj op` est interprété comme `obj.op`

scala> val ml = List(1,2,3,4)
ml: List[Int] = List(1, 2, 3, 4)

scala> ml.map((x)=>2*x)
res0: List[Int] = List(2, 4, 6, 8)

scala> def m(x:Int) = 2*x
m: (x: Int)Int

scala> ml.map(m)
res1: List[Int] = List(2, 4, 6, 8)

scala> def m(x:Int) = 3*x
m: (x: Int)Int

scala> ml.map(m)
res2: List[Int] = List(3, 6, 9, 12)

Vous pouvez ajouter un trait de soulignement après le nom de la méthode pour la forcer à devenir une fonction.

Remarque :Il doit y avoir au moins un espace entre le nom de la méthode et le trait de soulignement !

scala> def m3(x: Int): Int = x * x * x
m3: (x: Int)Int

scala> val f3 = m3_
<console>:10: error: not found: value m3_
       val f3 = m3_
                ^

scala> val f3 = m3 _
f3: Int => Int = <function1>

scala> f3(3)
res0: Int = 27

URL d'origine : https://www.cnblogs.com/shihuc/p/5082701.html