Implizite Parameter und Konvertierungen in Scala

Nachdem Tyts und Tyts die vorherigen Artikel über Habr durchgesehen hatten, konnten sie nicht schnell verstehen, was Implizite in Scala bewirken . Versuchen wir es gemeinsam herauszufinden.


Mit implizit in Scala können Sie also das Aufrufen von Methoden oder explizite Verweise auf Variablen vermeiden und stattdessen dem Compiler ermöglichen, die erforderlichen impliziten Daten selbst zu finden.

Zum Beispiel könnten wir eine Funktion schreiben, um von Float nach Int (FloatToInt) zu konvertieren, und anstatt diese Funktion explizit aufzurufen, würde der Compiler dies implizit für uns tun:

def double(value: Int) = value * 2 implicit def FloatToInt(value: Float):Int = value.toInt println(double(2.5F)) 

Verwirrt? Lassen Sie uns alles in Ordnung bringen.

Heute betrachten wir zwei implizite Kategorien, nämlich:

• Implizite Parameter (Werte). Sie werden automatisch von den implizit deklarierten Compilerwerten übergeben.
• Implizite Konvertierung Wenn der Typ des erwarteten Parameters nicht mit dem Eingabeparameter übereinstimmt, sucht der Compiler nach einer Methode in dem Bereich, der als implizit und mit dem in dieser Situation erforderlichen erwarteten Parameter und Eingabeparameter markiert ist, und übergibt ihn automatisch.

Impliziter Parameter

Ein impliziter Parameter ist ein Funktionsparameter, dem das implizite Schlüsselwort vorangestellt ist. Wenn beim Aufrufen der Funktion kein Wert übergeben wird, sucht der Compiler persönlich nach dem impliziten Parameter und übergibt ihn für uns.

Eine solche Funktion, die einen impliziten Parameterwert als Eingabe verwendet und verdoppelt:

 def double(implicit value: Int) = value * 2 

Ohne einen impliziten Parameter schlägt dies mit einem Fehler fehl:

 def double(implicit value: Int) = value * 2 println(double) // error: could not find implicit value for parameter value 

Wenn ein expliziter Parameter übergeben wird, funktioniert es:

 def double(implicit value: Int) = value * 2 println(double(3)) // 6 

Mit einem impliziten Parameter sieht es folgendermaßen aus:

 def double(implicit value: Int) = value * 2 implicit val multiplier = 2 println(double) // 4 

Aber Sie müssen vorsichtig sein:

 def double(implicit value: Int) = value * 2 implicit val multiplier = 2 implicit val multiplier2 = 1 println(double) // error: ambiguous implicit values 

Und schließlich ein Beispiel mit der Übergabe von def als impliziten Parameter:

 def double(implicit value: Int) = value * 2 val cappucinoLarge: Boolean = false implicit def cappucinoPrice: Int = if (cappucinoLarge) 200 else 100 println(double) // 200 

Das heißt, Am Ende werden wir Erfolg haben

 double(cappucinoPrice()) 

Anmerkungen zur Syntax:

 def func1(implicit value1: Int) // value1  def func2(implicit value1: Int, value2: Int) // value1  value2  def func3(value1: Int, implicit value2: Int) //   def func4(value1: Int)(implicit value2: Int) //  value2  def func5(implicit value1: Int)(value2: Int) //   def func6(implicit value1: Int)(implicit value2: Int) //   

Implizite Konvertierung

Zurück zum Beispiel von Float zu Int:

 def double(value: Int) = value * 2 implicit def FloatToInt(value: Float):Int = value.toInt println(double(2.5F)) 

Beim Aufruf von double haben wir eine Typinkongruenz des erwarteten Parameters (Int) mit dem Eingabeparameter (Float). Daher sucht der Compiler nach einer Methode im Bereich, die implizit markiert ist und den erwarteten Parameter (Int) und den Eingabeparameter (Float) aufweist, die in dieser Situation erforderlich sind. Findet FloatToInt, führt die Konvertierung durch und übergibt den gewünschten Wert weiter an double.

Jetzt hoffe ich, dass es klarer geworden ist. Alle Erfolge bei der Beherrschung von Scala!