Kotlin 科特林-无效与单位与无

Kotlin有三种性质非常相似的类型：

• Void

• 单元

• Nothing

看起来他们几乎犯了JavaScript错误：

• null

• 未定义

• void（0）

---

假设它们没有犯同样的错误，它们都是为了什么？它们有什么区别？

Void

是不可辩驳的类型。它是一个普通的Java类，在Kotlin中没有特殊意义

单位

类型只有一个值。替换Java

void

（注意：不是

void

）。更多信息请访问

---

Nothing

没有实例（就像

Void

）。它代表了“一个永远不存在的价值”。在Kotlin中，如果抛出错误，则为

Nothing

（请参阅）。

类型为Java。通常不会从Kotlin使用它，除非您使用的是使用它的Java库

单元

类型是从不返回任何感兴趣内容的函数返回的类型。这种功能通常会产生某种副作用。单位类型只有一个可能的值，即。当在Java中使用

void

（小写v）时，在Kotlin中使用

Unit

作为返回类型

Nothing

类型没有值。如果函数具有返回类型

Nothing

，则它无法正常返回。它要么抛出异常，要么进入无限循环。调用返回类型为Nothing的函数后的代码将被Kotlin编译器标记为不可访问

因为

Nothing

没有值，

Nothing？

实际上是只捕获Kotlin中

null

值的类型。

---

单元

---

单元

类似于

void

在Kotlin中，当函数不返回任何有意义的值时，它被声明为返回

Unit

，就像Java中的

void

：

fun greet(): Unit { println("Good day!") }

当函数返回

Unit

时，通常会跳过写入

Unit

，因为编译器认为

Unit

是默认的返回类型：

fun greet() { println("Good day!") }

---

单元

是一个单体

单元

是一个只有一个对象（单例模式）的类，该对象就是

单元

本身。它在

kotlin

包中使用对象声明声明，如下所示：

public object Unit {
    override fun toString() = "kotlin.Unit"
}

---

函数式编程中的单元

Kotlin拥有一流的功能编程支持。函数式编程语言中通常有一个

单元

。通过使所有函数都声明为具有返回值（即使函数不返回值），它使函数类型更具可读性：

val greet: () -> Unit = { println("Good day!") }

这里，

（）->Unit

是一种函数类型，

->

后面的

Unit

表示该函数类型不返回任何有意义的值。在函数类型中不能跳过提及

单元

---

单元

用于扩展泛型

每个函数都必须返回一个值。Kotlin决定用一个类来表示这一点，而不是用Java中的特殊类型

void

。使用类的原因是，通过使其成为类型层次结构的一部分，可以使类型系统更加一致

例如，假设我们有一个名为

Worker

的通用

接口

，它执行一些工作。此接口的

doWork（）

函数执行一些工作，必须返回一个值

T

：

interface Worker<T> {
    fun doWork(): T
}

这就是

Unit

的神奇之处，在这里我们可以使用原先设计用于返回值的现有接口。在这里，我们让

doWork（）

函数返回

Unit

值，以满足我们没有任何可返回的目的。因此，当重写返回泛型参数的函数时，它非常有用

请注意，我们还跳过了

doWork（）

函数的

Unit

返回类型。也不需要编写

return

语句

---

Nothing

---

无

的值永远不存在

在Kotlin中，类

Nothing

表示一个从不存在的值。这个类永远不可能有任何值/对象，因为它的

构造函数

保持

私有

。它在

kotlin

包中定义如下：

public class Nothing private constructor()

interface Worker<T> {
    T doWork();
}

class LogWorker implements Worker<Void> {
    @Override public Void doWork() {
        // Do the logging
        return null;
    }
}

Nothing

用于从不返回值的函数的返回类型。例如，具有无限循环的函数或总是引发异常的函数。Kotlin标准库中的

error（）

函数就是一个示例，它总是抛出异常并返回

Nothing

。下面是它的代码：

fun error(message: Any): Nothing = throw IllegalStateException(message.toString())

---

无

是底部类型

在函数式编程中，没有值的类型称为底部类型，它是所有其他类型的子类型。因此，

Nothing

是Kotlin中所有类型的子类型，就像

Any？

是所有类型的超类型一样。因此，

Nothing

类型的值（不存在）可分配给所有类型的变量，例如：

val user: User = request.user ?: error("User not found")

这里，如果

用户

为

null

，我们将使用elvis运算符（

？：

）调用前面定义的

error（）

函数。

error（）

函数返回类型

Nothing

的值，但它可以分配给类型

User

的变量，因为

Nothing

是

User

的子类型，就像它是任何其他类型的子类型一样。编译器允许这样做，因为它知道

fun getUser(request: Request): User {
    return request.user ?: error("User not found")
}

fun deleteFiles(files: List<File>? = null) {
    if (files != null) files.forEach { it.delete() }
}

// This function is already defined in the Kotlin standard library
fun emptyList() = object : List<Nothing> {
    override fun iterator(): Iterator<Nothing> = EmptyIterator
    ...
}

fun deleteFiles(files: List<File> = emptyList()) {
    files.forEach { it.delete() }
}

interface Worker<T> {
    T doWork();
}

class LogWorker implements Worker<Void> {
    @Override public Void doWork() {
        // Do the logging
        return null;
    }
}