Kotlin学习之函数

原文链接 Understanding Kotlin Functions

函数的基本使用

函数的声明与定义

用关键字fun来声明函数，然后是函数名字，参数列表，返回值和函数体：修饰符 fun 函数名(参数列表) :返回类型 {函数体}

• 修饰符，对于类的成员函数才有，一般是权限open/private
• fun，用于声明这是一个函数的关键字
• 函数名，就像变量名一样，是函数的名字
• (参数列表)，要用括号约束起来，就是变量的声明，多个要用逗号分隔
• :返回类型，注意冒号，也即是函数返回值的类型，如果很明显类型可以推断出来时，就可以省略
• {函数体}，也即函数的真实定义部分，想要执行的一些语句

如：

fun double(x: Int): Int {
     return x + x
}

这就是一个标准的函数。

函数的使用

函数的使用有三种，一是调用，另一种是声明变量，再有就是当作参数（这其实是在定义一个变量，然后当作参数）。

函数的调用

函数都是表达式，都有返回值，但可以不用管返回值，调用函数的时候用括号来标识，比如前面的函数double，可以这样来调用：

val dx = double(5)

这是函数最为常用的使用方法，因为程序最终要执行，所以所有的函数最终都是要被调用的。

声明函数变量

前面说了，函数是一级类型，它可以像其他类型那样去定义变量，比如前面的double也可以这来写：

    val myDouble = {x: Int -> x + x}
    println(myDouble(6))

这里的myDouble就是一个函数变量，它的函数类型与前面的double是一样的，它是一个变量，要想执行它的函数体要加括号。

把函数当作参数

这里会涉及高阶函数，高阶函数就是涉及函数中的函数，主要体现在函数的参数或者返回值也是一个函数。比如数组和集合的过滤(filter)和遍历(forEach)里面的参数就是一个函数：

    val asc = arrayOf(1, 2, 3, 4, 5)
    asc.filter({(it and 0x01) == 0}).map(myDouble).forEach({ println(it) })
    // output-> 4, 8

因为把函数当作参数传递时都涉及函数的类型定义，而一般情况下用lambda是最方便的，先有个印象，后面会详细讲解。

参数

函数的参数还有两种比较有用的变体，称之为命名参数和默认值，这两个通常会一起使用。

命名参数

fun log(tag: String, event: String, source: String, amount: Int, price: Float, persist: Boolean): Unit {
    println("$tag, $event, $amount $price")
    if (persist) {
        // write to file
    }
}

log("func", "Function arguments", "Hard way", 5, 2.3f, false)

   log(event = "Named arguments",
        tag = "func",
        source = "Elegant",
        amount = 5,
        persist = false,
        price = 100f
    )

参数默认值

fun foo(x: Int, y: Int = 0): Int {
    return x + y
}

fun afoo(x: Int = 0, y: Int): Int {
    return x - y
}

foo(3)
afoo(y = 5)

foo(3, 5)
afoo(3, 5)

fun log(tag: String, event: String, source: String = "Elegant", amount: Int = 0, price: Float, persist: Boolean = false): Unit {
    println("$tag, $event, $amount $price")
    if (persist) {
        // write to file
    }
}

    log(event = "Named arguments",
        tag = "func",
        price = 100f
    )

返回值

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

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

fun double(x: Int): Int = x + x

fun double(x: Int) = x + x

解构返回

Kotlin的函数只能有一个返回值，代表某一个类型的一个变量，如果想有多个返回值，就需要用复杂的类型，比如同一类型的多个有规律的变量可能就要用集合，如数组列表等。但如果类型不同，但逻辑上有关系的2个到3个值，如果想要一起返回，就需要用到组合类型如Pair和Triple，Pair可以把两个不同类型的变量组合成一个对象，Triple可以把三个不同类型的变量组合成一个对象，这样就可以在函数中返回了。

fun nameAge() = Pair("Alex", 50)

fun fullName() = Triple("Donald", "Jonh", "Trump")

对于函数的调用者也很麻烦，要先声明Pair或者Triple对象，然后再拆解，比如这样：

val pna = nameAge()
println("Name ${pna.first}, age ${pna.second}")

这显然比较笨拙，不够简洁。在Kotlin中有更好的做法，可以在函数调用的时候，对返回值进行拆解，称之为解构，如下写法与上面是一样的：

val (name, age) = nameAge()
println("Name $name, age $age")

而且，如果只对组合中的某几个感兴趣，可以把不想要的变量用下划线_(underscore)来表示，比如说：

val (firstName, _, lastName) = fullName()
println("This is $firstName $lastName")

尾部lambda参数传递

前面说了函数可以作为参数传递给其他函数，但我们在使用的时候，一般会直接把一个lambda传递进去，比如说：

fun execute(a: Int, f: (Int)->Int): Int {
    if (a < 0) {
        return -1
    }
    return f(a)
}

调用的时候，可以这样：

execute(3, { it * it })

但更建议的方式是把lambda放到函数调用之外：

execute(5) { it + it }

再比如像集合的函数式写法，通常也只传递一个lambda，这时一般都写在函数调用之外，并且当目标函数没有其他参数时也即除了要传入的lambda外无其他参数时，代表函数调用的括号也可以省略：

val nums = arrayOf(1, 2, 3, 4, 5)
nums.filter { it and 0x01 == 0 } // 等同于filter({ it and 0x01 == 0 })
        .map { it * it } // 等同于map({ it * it })
        .forEach { println(it) } // 等同于forEach({ println(it) })

这样写非常的简洁，但会牺牲一些可读性，因为花样多了，就会比较难识别出来函数的声明与函数的调用，甚至有时候会分不清函数与普通的变量。所以，识别函数调用有两种方式，一是看有没有括号，另外就看有没有尾部lambda。

匿名函数

匿名函数就是不指定函数的名字，但保留关键字fun，通常用于把函数当作 参数传递给高阶函数时使用。如：

list.forEach(fun (item) { println(item) })

但，因为对lambda支持的非常好，所以凡事用到匿名函数的地言都可以用lambda来替换（当然了，lambda也是匿名函数的一个实现方式）。匿名函数的一个用处就 可以加代码标签(label)，以方便终止语句的精准控制，可以参见另一篇文章中关于局部控制的讨论，可能也只有这个地方适用匿名函数，其他情况都应该直接用lambda。

内部函数

就是定义在另外一个函数内部的函数，通常用作于传递参数或者返回值，如：

fun foo(): ()->Unit {
   fun bar() {
   	println("Func bar inside fun foo")
   }
   return bar
}

事实上，随处可见的lambda都可以算上是内部函数。

高阶函数

函数类型

实例化一个函数类型

lambda表达式

就是匿名隐式函数体，匿名是不用指定函数的名字，连参数的类型和返回值的类型也都省略，有时甚至连参数都可以省略，只有一个函数体，是最为简洁的一种函数定义方式，通常用于传递给高阶函数的参数，lambda力求简洁，所以但凡能推断出来的都可以省略。最简洁的lambda只有函数体，如val asc = IntArray(5) { it * it } // 创建一个长度为5的整数数组并初始化为[0,1,4,9,16]。

lambda的形式是**{ A, B -> expressions }**，外面的花括号不可省略，这是lambda的标识，然后是参数列表，->用于分隔参数和函数体，除了函数体，其余的都可以省略掉，只要能推断出来。

Trailing lambdas(尾部lambda)

这个前面讲过了，再复习一下，当一个函数的最后一个参数是一个函数时，就可以在函数的调用外部写lambda，比如：

val product = items.fold(1) { acc, e -> acc * e }

run { println("...") }

隐式参数

如果lambda表达式只有一个参数，那么这个参数也可以省略，只写函数体就可以，并且可以用隐式参数it，比如：

ints.filter { it > 0 } // this literal is of type '(it: Int) -> Boolean'

val asc = IntArray(5) { it * it } 

lambda的返回值

lambda力求简洁，所以函数体的最后一个表达式的值即是此lambda的返回值，一般不用显式的return：

ints.filter { it > 0 } // boolean result of 'it > 0' is returned

val asc = IntArray(5) { it * it } // it * it is the return

ints.filter {
    val shouldFilter = it > 0
    shouldFilter
}

如果要用显式的return语句，要注意scope，在这篇文章有深入讨论，用隐式label来限定scope：

ints.filter {
    val shouldFilter = it > 0
    return@filter shouldFilter
}

丢弃参数

有时候，参数有多个，但可能并不会全都使用，仅使用了其中一个，这时不使用的参数就可以用**下划线_(underscore)**来代替，以表示这个参数不会被使用：

map.forEach { (_, value) -> println("$value!") }

Kotlin的lambda可以写出非常简洁的函数式链式语句，一气呵成可读性又非常的好，比如：

val headers = fetchHeaders()
headers.filter { it.length == 5 }
	.sortedBy { it }
	.map { it.uppercase() }
	.forEach { println(it) }

未完待续

函数是Kotlin中最最重要的一个类型，博大精深，用法多样，但万变不离其宗，重点理解函数就是行为，是可以运行的一组语句和表达式的小集合；区分开函数的声明和定义就可以了。

Kotlin的函数类型很多，这里只介绍了一些基础，后面将会继续介绍一些高级的函数如内联函数(inline functions)，infix notation以及Extensions和Scope functions。

参考资料

• Kotlin functions
• Kotlin | Default and Named argument
• Kotlin——高级篇（一）：Lambda表达式详解
• Lambda Expressions in Kotlin
• Kotlin lambda表达式

原创不易，打赏，点赞，在看，收藏，分享 总要有一个吧