Kotlin官方文档翻译—《Functions and Lambdas-Functions》

函数

函数声明

在Kotlin中函数使用fun关键字声明：

fun double(x: Int): Int {
    return 2*x
}

函数的使用

传统的函数调用：

val result = double(2)

用 · 符号调用成员函数：

Sample().foo() // create instance of class Sample and call foo

参数

函数参数使用帕斯卡命名法定义，例如name:type，多个参数之间使用逗号隔开。每个参数的类型必须被显示定义：

fun powerOf(number: Int, exponent: Int) {
...
}

默认参数

当函数的某个参数被省略时，可以使用其默认值。相比其他语言，这可以节省大量的重载函数：

fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size) {
...
}

默认值紧随参数类型，用=表示。

覆写方法通常和基类方法使用相同的默认参数。当覆写方法时，必须在参数声明时省略默认值：

open class A {
    open fun foo(i: Int = 10) { ... }
}

class B : A() {
    override fun foo(i: Int) { ... }  // no default value allowed
}

如果一个有默认值的参数在另一个无默认值参数之前，使用函数时，有默认值的参数可以被省略：

fun foo(bar: Int = 0, baz: Int) { /* ... */ }

foo(baz = 1) // The default value bar = 0 is used

但是如果函数最后一个参数是lambda表达式并且在括号外面调用时，是可以不传默认参数值的：

fun foo(bar: Int = 0, baz: Int = 1, qux: () -> Unit) { /* ... */ }

foo(1) { println("hello") } // Uses the default value baz = 1 

foo { println("hello") }    // Uses both default values bar = 0 and baz = 1

命名参数

函数参数可以在调用时命名，这在函数有大量参数或者默认参数时相当方便。

看下面这个函数：

fun reformat(str: String,
             normalizeCase: Boolean = true,
             upperCaseFirstLetter: Boolean = true,
             divideByCamelHumps: Boolean = false,
             wordSeparator: Char = ' ') {
...
}

我们可以使用默认参数调用它：

reformat(str)

当我们不想使用默认参数，还可以这样：

reformat(str, true, true, false, '_')

使用命名参数可以让代码更易读：

reformat(str,
    normalizeCase = true,
    upperCaseFirstLetter = true,
    divideByCamelHumps = false,
    wordSeparator = '_'
)

如果我们不想要所有参数：

reformat(str, wordSeparator = '_')

当一个函数既有位置参数又有命名参数时，所有位置参数都应该在命名参数之前。例如f(1, y = 2)是可以的，但f(x = 1, 2)就不行。

可变参数可以使用扩展操作符被传入：

fun foo(vararg strings: String) { /* ... */ }

foo(strings = *arrayOf("a", "b", "c"))

foo(strings = "a") // Not required for a single value

请注意，在调用Java函数时，不能使用命名参数的语法，因为Java字节码不总是保存函数的参数名。

返回unit的函数

如果一个函数不返回任何有用信息，那么它将返回Unit。Unit是一种只有一个值—Unit的类型。它不用显示返回：

fun printHello(name: String?): Unit {
    if (name != null)
        println("Hello ${name}")
    else
        println("Hi there!")
    // `return Unit` or `return` is optional
}

Unit作为返回类型也是可以省略的，上面的代码等价于：

fun printHello(name: String?) {
    ...
}

单表达式函数

当一个函数只返回一个单表达式时，大括号可以省略不写，函数体可以写在=后面：

fun double(x: Int): Int = x * 2

当编译器可以推测类型时，显示声明的返回类型也可以省略：

fun double(x: Int) = x * 2

显示声明返回类型

具有块代码体的函数通常需要显示声明返回类型，除非打算返回Unit，则可以省略返回类型。Kotlin无法为带块代码体的函数推断返回类型，因为这些函数的代码体中可能有复杂的控制流，并且返回类型对读者而言也不明显（有时候对于编译器也是如此）。

可变参数

函数参数（通常是最后一个）可以被vararg修饰：

fun <T> asList(vararg ts: T): List<T> {
    val result = ArrayList<T>()
    for (t in ts) // ts is an Array
        result.add(t)
    return result
}

可以传入数量不定的参数：

val list = asList(1, 2, 3)

在函数内部，可变参数的类型T可以看做是数组类型T，即上例中的变量ts具有类型Array<out T>。

只有一个参数可以标识为可变参数。如果可变参数不在参数列表最后，它后面的参数可以使用命名参数的语法传递，或者，假如参数是函数类型，可以在括号外面传入lambda表达式。

当我们调用具有可变参数的函数时，我们可以一个个传入参数，例如，asList(1, 2, 3)，另外，如果我们已有一个数组，想把数组元素传入函数，我们可以在数组前使用扩展操作符*：

val a = arrayOf(1, 2, 3)
val list = asList(-1, 0, *a, 4)

中缀表达式

函数在以下情况可以使用中缀表达式：

• 它们是成员函数或者扩展函数；
• 它们只有单一参数；
• 它们被infix关键字标记。

// Define extension to Int
infix fun Int.shl(x: Int): Int {
...
}

// call extension function using infix notation

1 shl 2

// is the same as

1.shl(2)

函数作用域

在Kotlin中函数可以在文件顶层声明，这意味着你不用像Java、C#或者Scala这些语言那样，创建一个类来保存函数。除了顶层函数，Kotlin函数也可以在局部作用域声明为成员函数和扩展函数。

局部函数

Kotlin支持局部函数，即一个函数在另一个函数内部：

fun dfs(graph: Graph) {
    fun dfs(current: Vertex, visited: Set<Vertex>) {
        if (!visited.add(current)) return
        for (v in current.neighbors)
            dfs(v, visited)
    }

    dfs(graph.vertices[0], HashSet())
}

局部函数可以访问外部函数的局部变量，即闭包，所以在上面的例子中，visited可以是局部变量：

fun dfs(graph: Graph) {
    val visited = HashSet<Vertex>()
    fun dfs(current: Vertex) {
        if (!visited.add(current)) return
        for (v in current.neighbors)
            dfs(v)
    }

    dfs(graph.vertices[0])
}

成员函数

成员函数是定义在类或者对象内部的函数：

class Sample() {
    fun foo() { print("Foo") }
}

成员函数可以使用点符号调用：

Sample().foo() // creates instance of class Sample and calls foo

更多类和覆写成员函数的信息请参照 Class 和 Inheritance

泛型函数

函数可以有泛型参数，只需在函数名前加尖括号：

fun <T> singletonList(item: T): List<T> {
    // ...
}

更多泛型函数的信息请参照Generics。

内联函数

内联函数请点我。

扩展函数

扩展函数请点我

高阶函数和Lambda表达式

请点我

尾递归函数

Kotlin支持一种被称为尾递归函数的编程方式。它允许那些通常可以用循环书写的算法改用递归函数，而无堆栈溢出的风险。当一个函数用tailrec修饰符白标记并满足所需要的形式时，编译器就会优化这个递归，留下一个快速高效的基于循环的版本：

tailrec fun findFixPoint(x: Double = 1.0): Double
        = if (x == Math.cos(x)) x else findFixPoint(Math.cos(x))

这段代码用于计算余弦的固定点，这是一个数学常量。就是从1开始重复调用Math.cos直到结果不再改变，得出的结果是0.7390851332151607。上面这段代码等价于传统的写法：

private fun findFixPoint(): Double {
    var x = 1.0
    while (true) {
        val y = Math.cos(x)
        if (x == y) return y
        x = y
    }
}

为了满足tailrec修饰符的条件，函数必须以调用它本身作为最后一个操作。当在递归调用以后还有更多代码时，是不能使用尾递归函数的。同样的，在try-catch-finally代码块中也不能使用。目前尾递归函数仅在JVM后端支持。