Functions and Lambdas

infix notation

可以定义中缀函数

infix fun Int.add(another:Int):Int {
    return this + another
}
// call example var c = 1 and 2

Function Scope

kotlin 支持函数嵌套定义

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]) 
}

支持inline function
支持尾递归优化，需使用tailrec关键字

High-Order Functions

高阶函数：返回或者接收函数的函数

fun <T> lock(lock: Lock, body: () -> T): T { 
    lock.lock()
    try {
            return body() 
        } finally { 
            lock.unlock()
        }
}

fun <T, R> List<T>.map(transform: (T) -> R): List<R> { 
    val result = arrayListOf<R>()
    for (item in this)
        result.add(transform(item)) 
        return result
    }
}
val doubled = ints.map { it -> it * 2 }
or ints.map { it * 2 } // one params it-> can be omitted

Lambda

var sum = {x:Int, y:Int -> x+y}
val sum:(Int, Int)->Int={x, y->x+y}
val sum: (Int, Int) -> Int = { x, y ->
    println(x);
    x+ 3 ;
    x + y
}
// 如果只有一个参数，可以使用it来代替

lambda可以声明返回值类型，但是如果能推断出返回类型，我们就无需定义

Anonymous Functions

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

如果参数的数据类型能被推断出来的话也可以省略之
lambda 和匿名函数的区别主要在于，lambda无法声明return 表达式

Closures

var sum = 0
ints.filter { it > 0 }.forEach {
    sum += it 
}
print(sum)

匿名函数或者lambda表达式可以访问作用域范围内的变量

Function Literals With Receiver

我们可以定义函数的接受对象
sum :Int.(other:Int)->Int
此时sum被定义为带Int接收者的函数
1.sum(2)//这个有点类似扩展函数，我们可以将其当做Int的扩展函数
val sum = fun Int.(other:Int):Int = this + other

class HTML {
fun body() { ... }
}
fun html(init: HTML.() -> Unit): HTML {
    val html = HTML() // create the receiver object
    html.init() // pass the receiver object to the lambda return html
}
html {       // lambda with receiver begins here
    body()   // calling a method on the receiver object
}

Inline Functions

kotlin支持inline noinline关键字
函数内部如果是内联函数，则可以从内部函数直接返回，否则不行

fun foo() {
  ordinaryFunction {
     return // ERROR: can not make `foo` return here
  }
  inlineFunction {
    return // OK: the lambda is inlined
  }
}

我们在lambda表达式中无法直接使用return返回，需要使用return label
如果lambda表达式被当作函数实参，而此实参又被函数内部其他上下文使用，我们此时需要添加crossinline字段来保证此lambda能正常使用 non-local control

Cast

a as String // if fail(a is null) throw an exception
a as String? // safe even a is null
a as? String // return null if a is null

Equality

=== 绝对相等，引用地址相同
== 检测equals相等

Operator overloading

kotlin支持操作符的重载

Null Check

类似 swift
空判断后kotlin会自动将相关变量转换为非空类型
b?.length // return b.length or null if b is null
val name=b?.name ?: "" // 如果?:左侧表达式为null则返回执行右侧的表达式
b!!.length() // 强制b非空，如果为空则抛出异常

支持注解

Class References

MyClass::class 可以得到KClass,其和java的class是有区别的，若要获得java class,访问KClass.java

Function References

对于java平台而言，如果需要访问反射相关api需要单独引入kotlin-reflect.jar
fun isOdd(x:Int)=x%2!=0
我们可以使用::isOdd来引用函数，如果我们希望引用成员函数，可以使用类似String::toCharArray来引用

Type-Safe Builders

just like groovy

fun result(args: Array<String>) = html {
    head {
      title {+"XML encoding with Kotlin"}
    }
    body {
          h1 {+"XML encoding with Kotlin"}
          p  {+"this format can be used as an alternative markup to XML"}
          // an element with attributes and text content
    a(href = "http://kotlinlang.org") {+"Kotlin"}
          // mixed content
    p{
    +"This is some"
    b {+"mixed"}
    +"text. For more see the"
    a(href = "http://kotlinlang.org") {+"Kotlin"} +"project"
    }
    p {+"some text"}
          // content generated by
    p{
    for (arg in args)
    +arg }
    }
 }