Question

我正在关注Scala的教程，我看到了：

object implicitFunctions extends App {
    println("Step 1: How to create a wrapper String class which will extend the String type")
    class DonutString(s: String) {
        def isFavoriteDonut: Boolean = s == "Glazed Donut"
    }

    println("\nStep 2: How to create an implicit function to convert a String to the wrapper String class")
    object DonutConversions {
        implicit def stringToDonutString(s: String) = new DonutString(s)
    }

    println("\nStep 3: How to import the String conversion so that it is in scope")
    import DonutConversions._

    println("\nStep 4: How to create String values")
    val glazedDonut = "Glazed Donut"
    val vanillaDonut = "Vanilla Donut"

    println("\nStep 5: How to access the custom String function called isFavaoriteDonut")
    println(s"Is Glazed Donut my favorite Donut = ${glazedDonut.isFavoriteDonut}")
    println(s"Is Vanilla Donut my favorite Donut = ${vanillaDonut.isFavoriteDonut}")
}

到底发生了什么？我想在String类上找不到任何方法，因此我们通过调用函数调用String来查看导入的implicits并从stringToDonutString进行转换，并传入缺少方法（字符串）。是吗？

为什么隐式必须包装在一个对象中？

Answer 1

 ${glazedDonut.isFavoriteDonut}"

当调用上述内容时，编译器会在String中搜索isFavoriteDonut方法（因为glazedDonut的类型为String）。当然，它找不到它。

然后编译器会搜索一个隐式的，可以将String转换为其他类型（让我们称之为Unknown），这样Unknown类型包含isFavoriteDonut方法。

它在范围内找到了这样一个隐含的函数，它可以转换String => DonutString并且它知道DonutString包含glazedDonut

为什么隐式必须包装在一个对象中？

规范不允许创建顶级implicit类和函数。 https://scala-lang.org/files/archive/spec/2.12/07-implicits.html

隐式修饰符对于所有类型成员以及顶级对象都是非法的。

Answer 2

它被包装在DonutString中，因此您可以在其上调用DonutString方法，例如isFavoriteDonut。

Scala中的隐含函数。这是怎么回事？

2 个答案: