Kotlin语言编程技巧集

空语句

Kotlin 语言中的空语句有

• {}
• Unit

when (x) {
    1 -> ...
    2 -> ...
    else -> {}
    // else -> Unit
}

When 表达式

使用不带判断条件的 when 表达式来改写多路分支

val v = if (x < y) 1 else if (x == y) 2 else 3

val v = when {
    x < y -> 1
    x == y -> 2
    else -> 3
}

使用带判断条件的 when 表达式来模拟模式匹配

val v = if (x == 1) 1 else if (x == 2) 3 else 5

val v = when (x) {
    1 -> 1
    2 -> 3
    else -> 5
}

?. 与 ?:

// n的值为a,b,c,4当中第一个不是null的数
val n = a ?: b ?: c ?: 4

a	b	c	n
1	/	/	1
null	2	/	2
null	null	3	3
null	null	null	4

// n的值为a.b.c，条件是a,a.b,a.b.c都不是null。否则n的值为4。
val n = a?.b?.c ?: 4

a	a.b	a.b.c	n
null	/	/	4
!= null	null	/	4
!= null	!= null	null	4
!= null	!= null	3	3

使用解构声明来声明两个带值的变量

var (a, b) = listOf(1, 2) // a == 1, b == 2
var (a, b) = Pair(1, 2) // a == 1, b == 2
var (a, b) = 1 to 2 // a == 1, b == 2

let

the tldr; on Kotlin’s let, apply, also, with and run functions

// Calls the specified function [block] with `this` value as its argument and returns its result.
public inline fun <T, R> T.let(block: (T) -> R): R = block(this)

调用代码块，代码块中调用方 this 为参数 it，返回代码块的结果。

// using 'let' to convert from one type to another
val answerToUniverse = strBuilder.let {
    it.append("Douglas Adams was right after all")
    it.append("Life, the Universe and Everything")
    42
}
// using 'let' to only print when str is not null
str?.let { print(it) }

apply

// Calls the specified function [block] with `this` value as its receiver and returns `this` value.
public inline fun <T> T.apply(block: T.() -> Unit): T { block(); return this }

调用代码块，代码块中调用方 this 为隐式调用方 receiver，返回调用方 this。

// old way of building an object
val andre = Person()
andre.name = "andre"
andre.company = "Viacom"
andre.hobby = "losing in ping pong"
// after applying 'apply' (pun very much intended)
val andre = Person().apply {
    name = "Andre"
    company = "Viacom"
    hobby = "losing in ping pong"
}

also

// Calls the specified function [block] with `this` value as its argument and returns `this` value.
public inline fun <T> T.also(block: (T) -> Unit): T { block(this); return this }

调用代码块，代码块中调用方 this 为参数 it，返回调用方 this 。

// transforming data from api with intermediary variable
val rawData = api.getData()
Log.debug(rawData)
rawData.map {  /** other stuff */  }
// use 'also' to stay in the method chains
api.getData()
    .also { Log.debug(it) }
    .map { /** other stuff */ }

with

// Calls the specified function [block] with the given [receiver] as its receiver and returns its result.
public inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()

调用代码块，代码块中指定参数为隐式调用方 receiver，返回代码块的结果。

// Every Android Developer ever after Wednesday May 17th 2017
    messageBoard.init(“https://url.com”)
    messageBoard.login(token)
    messageBoard.post("Kotlin’s a way of life bro")

// using 'with' to avoid repetitive references to identifier
with(messageBoard) {
    init(“https://url.com”)
    login(token)
    post(“Kotlin’s a way of life bro")
}

run

// Calls the specified function [block] with `this` value as its receiver and returns its result.
public inline fun <T, R> T.run(block: T.() -> R): R = block()

调用代码块，代码块中调用方 this 为隐式调用方 receiver，返回代码块的结果。

// GoT developers after season 7
aegonTargaryen = jonSnow.run {
    makeKingOfTheNorth()
    swearsFealtyTo(daenerysTargaryen)
    realIdentityRevealed(“Aegon Targaryen”)
}

let, apply, also, with & run

代码块／函数	let	apply	also	with	run
参数或调用方 this 为隐式调用方 receiver		○		○	○
调用方 this 为参数 it	○		○
返回调用方 this		○	○
返回代码块的结果	○			○	○

takeIf / takeUnless

difference between kotlin also, apply, let, use, takeIf and takeUnless in Kotlin

// Returns this value if it satisfies the given predicate or null, if it doesn't.
inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? = if (predicate(this)) this else null
// Returns this value if it does not satisfy the given predicate or null, if it does.
inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T? = if (!predicate(this)) this else null

takeIf：调用方 this 如果符合某个条件则返回调用方 this，否则返回 null。

takeUnless：调用方 this 如果不符合某个条件则返回调用方 this，否则返回 null。

println(myVar.takeIf { it is Person } ?: "Not a person!")
println(myVar.takeUnless { it is Person } ?: "It's a person!")