kotlin学习之函数

取自：https://www.kotlincn.net/docs/reference/functions.html

默认参数:

函数参数可以有默认值, 当省略相应的参数时使用默认值。与其他语言相比，这可以减少重载数量:

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

默认值通过类型后面的 = 及给出的值来定义。

覆盖方法总是使用与基类型方法相同的默认参数值。当覆盖一个地遨游默认参数值的方法时，必须从签名中省略默认参数值：

open class A{
	open fun getA(a:Int = 0){...}
}
class B:A(){
		override fun getA(a:Int ){...}  //不能有默认值
}

如果一个默认参数再一个无默认值的参数之前，那么该默认值只能通过使用命名参数调用该函数来使用：

fun foo(bar: Int = 0, baz: Int ){...}
foo(baz = 1)//使用默认值 bar=0

如果再默认参数之后的最后一个参数是lambda表达式，那么它既可以作为命名参数再括号内传入，也可以在括号外传入：

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

foo(1) { println("hello") } 		//使用默认值 baz = 1
foo(qux = { println("hello")} )		//使用两个默认值 bar = 0  baz = 1
foo { println("hello") }			//使用两个默认值 bar = 0  baz = 1

命名函数

可以在调用函数时使用命名的函数参数。当一个函数有大量的参数或者默认参数时这回非常方便。

给定以下函数：

fun reformat( str: Stirng,
			  isA: Boolean = true,
			  isB: Boolean = true,
			  isC: Boolean = false,
			  a: Char = ''
){...}

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

reformat(str)

然而，当使用非默认参数调用它时，该调用看起来就像：

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

使用命名参数我们可以使代码更具有可读性：

reformat(str,
		 isA = true,
		 isB = true,
		 isC = false,
		 a = '-'
)

并且如果我们不需要所有的参数：

reformat( str , a = '-' ) 

当一个函数调用混用位置参数与命名参数时，所有位置参数都要放在第一个命名参数之前。例如，允许调用 f(1,y = 2) 但不允许 f(x=1,2)。

可以通过使用 星号 操作符将 可变数量参数（vararg） 以命名形式传入：

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

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

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

可变数量的参数 （varargs）

函数的参数（通常是最后一个）可以用 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的 vararg参数的可见方式是作为 T数组，即上例中的 ts变量具有类型Array <outT>。

只有一个参数可以标注为vararg 。如果vararg参数不是列表中的最后一个参数，可以使用命名参数语法传递其后的参数的值，或者，如果参数具有函数类型，则通过在括号外部传一个lambda。

当我们调用vararg函数时，我们可以一个接一个的传参，例如 asList(1,2,3)，或者，如果我们已经有一个数组并希望将其内容传给该函数，我们使用 伸展（spread） 操作符（在数组前面加 *）:

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

单表达式函数

当函数返回单个表达式时，可以省略花括号并且在=符号之后指定代码体即可：

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

当返回值类型可由编译器推断时，显示声明返回类型时可选的：

fun double( x: Int ) = x * 2

中缀表示法

标有 infix关键字的函数也可以使用中缀表示法（忽略该调用的点与圆括号）调用。中缀汉书必须满足以下要求：

• 它们必须是成员函数或扩展函数；

• 它们必须只有一个参数；

• 其参数不得接受可变数量的参数且不能有默认值。

    infix fun Int.shl(x: Int): Int{...}
    
    //用中缀表示法调用该函数
    1 shl 2
    
    //等同于这样
    1.shl(2)
  

请注意，中缀函数总是要求指定接收者与参数。当使用中缀表示法在当前接收者上调用方法时，需要显示使用this；不能像常规方法调用那样省略。这是确保非模糊解析所必需的。

class MyStringCollection {
	infix fun add(s: String){...}
	
	fun build() {
		this add "abc"   //正确
		add("abc")   //正确
		add "abc"  		//错误：必须指定接收者
	}
}

函数作用域

在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() { println("Foo") }
}

成员函数以点表示法调用：

Sample().foo()  //创建类 Sample 实例并调用foo

泛型函数

函数可以有泛型参数，通过在函数名前使用尖括号指定：

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

内联函数

扩展函数

高阶函数和lambda表达式

尾递归函数

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

val eps = 1E-10 // "good enough", could be 10^-15

tailrec fun findFixPoint(x: Double = 1.0): Double
    		= if (Math.abs(x - Math.cos(x)) < eps) x else findFixPoint(Math.cos(x))

这段代码计算余弦的不动点（fixpoint of cosine），这是一个数学常数。 它只是重复地从 1.0 开始调用 Math.cos，直到结果不再改变，对于这里指定的 eps 精度会产生 0.7390851332151611 的结果。最终代码相当于这种更传统风格的代码：

val eps = 1E-10 // "good enough", could be 10^-15

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

要符合 tailrec修饰符的条件的话，函数必须将其自身调用作为它执行的最后一个操作。就在递归调用后有更多代码时，不能使用尾递归，并且不能用在 try/catch/finally 块中。目前尾部递归只在JVM后端中支持。