为什么 use 块不能安全地初始化 var？

Question

为什么会出现编译错误？

val autoClosable = MyAutoClosable()
var myVar: MyType
autoClosable.use {
    myVar= it.foo()
}
println(myVar) // Error: Variable 'myVar' must be initialized

也许编译器只是将{ myVar= it.foo() } 视为传递给另一个函数的函数，并且不知道何时甚至是否会执行它？

但是由于use 不只是一个函数，而是 Kotlin 替代 Java 的 try-with-resource，所以一些关于它的特殊知识是合适的，不是吗？现在，我不得不用一些虚拟值初始化myVar，这根本不符合 Kotlin 的精神。

Answer 1

由于use { ... } 不是语言结构而是is just a library function，编译器不知道（并且目前不努力证明）您传递的lambda 曾经执行过 .因此禁止使用未初始化的变量。

例如，将您的代码与此函数调用进行比较。如果没有额外的代码分析，它们对于编译器是相同的：

inline fun ignoreBlock(block: () -> Unit) = Unit

var myVar: MyType
ignoreBlock { myVar = it.foo() }
println(myVar) // Expectedly, `myVar` stays uninitialized, and the compiler prohibits it

要绕过这个限制，您可以使用从use 返回的值（这是您的块返回的值）来初始化您的变量：

val myVar = autoClosable.use {
    it.foo()
}

如果您还想处理它可能抛出的异常，请使用try as an expression：

val myVar = try {
    autoClosable.use {
        it.foo()
    }
} catch (e: SomeException) {
    otherValue   
}

理论上，实际上可以检查内联函数以仅调用一次 lambda，如果 Kotlin 编译器可以做到这一点，它将允许您的用例和其他一些用例。但这还没有实施。

Answer 2

如果在执行it.foo() 时发生异常，use 块将捕获异常，关闭您的autoClosable，然后返回。在这种情况下，myVar 将保持未初始化状态。

这就是为什么编译器不会让你做你想做的事。

Answer 3

这是因为use 是一个内联函数，这意味着 lambda 主体将内联到调用点函数，而变量 myVar 的实际类型取决于其上下文.

IF myVar 在 lambda 中用于读取，类型为 MyType 或其超类型。例如：

//      v--- the actual type here is MyType
var myVar: MyType = TODO()

autoClosable.use {
    myVar.todo()
}

IF myVar 在 lambda 中用于写入，实际类型是 ObjectRef。为什么？这是因为 Java 不允许您将变量更改出令人讨厌的类范围。事实上，myVar 是实际上是最终的。例如：

//  v--- the actual type here is an ObjectRef type.
var myVar: MyType

autoClosable.use {
    myVar = autoClosable.foo()
}

所以当编译器检查println(myVar) 时，它不能确定ObjectRef 的元素是否被初始化。然后引发编译器错误。

如果抓到什么，代码也编译不出来，例如：

//  v--- the actual type here is an ObjectRef type.
var myVar: MyType
try {
    autoClosable.use {
        myVar = it.foo()
    }
} catch(e: Throwable) {
    myVar = MyType()
}

//       v--- Error: Variable 'myVar' must be initialized
println(myVar) 

但是当myVar 的实际类型是MyType 时，它可以正常工作。例如：

var myVar: MyType
try {
    TODO()
} catch(e: Throwable) {
    myVar = MyType()
}

println(myVar) // works fine

为什么 kotlin 没有优化内联函数直接使用MyType 编写？

我唯一想的是，编译器不知道myVar 将来是否会在另一个内联函数的 lambda 主体中使用。或者 kotlin 想要保持所有函数的语义一致。