面向表达式编程

通俗地理解，表达式就是可以返回值的语句。

1 // 单纯的字面量表达式，值为1
-1 // 增加前缀操作符，值为-1
1+1 // 加法操作符，返回2
listOf(1,2,3) // 列表表达式 
"kotlin".length // 值为6 

这些都是非常明显的表达式。以下是Kotlin中更复杂的表达式例子：

{x: Int -> x + 1} // Lambda 表达式，类型为 (Int) -> Int
fun(x: Int) { println(x) } // 匿名函数表达式，类型为 (Int) -> Unit
if (x > 1) x else 1 // if—else表达式，类型为 Int，假设 x 已赋值

表达式比语句更安全

void ifStatement(Boolean flag) {
    String a = null;
    if (flag) {
        a = "dive into kotlin";
    }
    System.out.println(a.toUpperCase());
}

在Java中，由于if是语句而不是表达式，因此这里必须对变量a进行声明，这段代码潜在的问题是：a必须在if语句外进行声明并初始化为null，假设flag条件永远为true，那么程序运行不会报错，否则运行时将会抛出空指针异常（即使编译会通过）。这就是它的副作用。

而在下面的Kotlin版本中，使用if作为表达式就不会有这个问题：

fun ifExpression(flag: Boolean) {
    val a = if (flag) "dive into Kotlin" else ""
    println(a.toUpperCase())
}

在if作为表达式时，else分支也必须被考虑，这很容易理解，因为表达式具备类型信息，最终它的类型就是if、else多个分支类型的相同类型或公共父类型。可以看出，基于表达式的方案彻底消除了副作用，让程序变得更加安全。与 Java 的函数不同，Kotlin 中所有的函数调用也都是表达式。

Unit类型：让函数调用皆为表达式

为什么说 Java 中的函数不都是表达式，因为存在特例void，因为void函数没有返回值类型，它就不能算作一个表达式。

那么，Kotlin 为什么要引入 Unit 呢？一个很大的原因是函数式编程侧重于组合，尤其是很多高阶函数，在源码实现的时候都是采用泛型来实现的。然而void在涉及泛型的情况下会存在问题。

复合表达式：更好的表达力

相比语句而言，表达式更倾向于自成⼀块，避免与上下文共享状态，互相依赖，因此我们可以说它具备更好的隔离性。隔离性意味着杜绝了副作用，因此我们用表达式描述逻辑可以更加安全。此外，表达式通常也具有更好的表达能力。

典型的⼀个例子就是表达式更容易进行组合。由于每个表达式都具有值，并且也可以将另⼀个表达式作为组成其自身的⼀部分，所以我们可以写出⼀个复合的表达式。

val res: Int? = try {
    if (result.success) {
        jsonDecode(result.response)
    } else null
} catch (e: JsonDecodeException) {
    null
}

这个程序描述了获取一个HTTP响应结果，然后进行 json 解码，最终赋值给 res 变量的过程。它向我们展示了 Kotlin 如何利用多个表达式组合表达的能力：

• try在 Kotlin 中也是一个表达式，try/catch/finally语法的返回值类型由try或catch部分决定，finally不会产生影响；
• 在 Kotlin 中，if-else很大程度上代替了传统三元运算符的做法，虽然增加了语法词数量，但是减少了概念，同时更利于阅读；
• if-else的返回值即try部分的返回值，最终res的值由try或catch部分决定。

Kotlin 中的 “？：”

虽然Kotlin没有采用三元运算符，然而它存在⼀个很像的语法“ ?:”。注意，这里的问号和冒号必须放在⼀起使用，它被叫作 Elvis 运算符，或者 null 合并运算符。由于 Kotlin 可以用“?”来表示一种类型的可空性，我们可以用“ ?:”来给一种可空类型的变量指定为空情况下的值。你可以通过以下的例子理解 Elvis 运算符：

val maybelnt: Int? = null
maybelnt ?: 1 // 1

枚举类和 when 表达式

枚举是类

在Kotlin中，枚举是通过⼀个枚举类来实现的。

enum class Day { 
    MON, TUE, WED, THU, FRI, SAT, SUN 
}

跟Java相比写法上只多了一个calss关键字，但与 Java 的枚举不同的是，由于它是⼀种类，它可以拥有构造参数，以及定义额外的属性和方法。

enum class DayOfWeek(val day: Int) {
    MON(1),
    TUE(2), 
    WED(3), 
    THU(4), 
    FRI(5), 
    SAT(6), 
    SUN(7);
    // 如果以下有额外的方法或属性定义，则必须强制加上分号
    fun getDayNumber(): Int {
        return day
    }
}

用 when 来代替 if-else

fun schedule(sunny: Boolean, day: Day) = when (day) {
    Day.SAT -> basketball()
    Day.SUN -> fishing()
    Day.FRI -> appointment()
    else -> when {
        sunny -> library()
        else -> study()
    }
}

when表达式的具体语法：

• 1）一个完整的when表达式类似switch语句，由when关键字开始，用花括号包含多个逻辑分支，每个分支由->连接，不再需要switch的break（这真是⼀个恼人的关键字），由上到下匹配，一直匹配完为止，否则执行else分支的逻辑，类似switch的default；
• 2）每个逻辑分支具有返回值，最终整个when表达式的返回类型就是所有分支相同的返回类型，或公共的父类型。
• 3）when关键字的参数可以省略，如上述代码中的子when表达式（但是这种情况下->左侧的必须返回布尔值，否则编译会报错）
• 4）表达式可以组合，所以这是⼀个典型的when表达式组合的例子。你在 Java 中很少见过这么长的表达式，但是这在 Kotlin 中很常见。

when表达式还可以使用更加灵活的方式来解决嵌套深的问题：

fun schedule(sunny: Boolean, day: Day) = when {
    day == Day.SAT -> basketball()
    day == Day.SUN -> fishing()
    day == Day.FRI -> appointment()
    sunny -> library()
    else -> study()
}

再次强调，省略when()中的参数时，每个分支的左侧必须是一个返回Boolean类型的表达式。

for 循环和范围表达式

for (i in 1..10) println(i) 

与下面写法是等价的：

for (i: Int in 1..10) { 
	println(i)
}

事实上，任何提供迭代器（iterator）的结构都可以用for-in语句进行迭代，如：

for (c in array) { 
	println(c)
}

此外，我们还可以通过调用⼀个withIndex方法，提供一个键值元组：

for ((index, value) in array.withlndex()) { 
	println("the element at $index is $value") 
}

范围表达式

Kotlin官网中介绍：Range表达式是通过rangeTo函数实现的，通过“..”操作符与某种类型的对象组成，除了整型的基本类型之外，该类型需实现java.lang.Comparable接口。

举个例子，由于String类实现了Comparable接口，字符串值之间可以比较大小，所以我们就可以创建一个字符串区间，如：

"abc".."xyz"

另外，当对整数进行for循环时，Kotlin 还提供了一个 step 函数来定义迭代的步长：

for (i in 1..10 step 2) {
	print(i)
} 
>>> 13579

倒序方式：

for (i in 10 downTo 1 step 2) { // 通过 downTo，而不是 10..1
    print(i) 
}
>>> 108642

此外，还有⼀个until函数来实现⼀个半开区间：

for (i in 1 until 10) { 
	print(i) 
} 
>>> 123456789 // 并不包含 10

用 in 来检查成员关系

在Kotlin中我们可以用in来检查一个元素是否是一个区间或集合中的成员。

"a" in listOf("b", "c") 
>>> false

如果我们在in前面加上感叹号，那么就是相反的判断结果：

"a" !in listOf("b", "c") 
>>> true

除了等和不等，in还可以结合范围表达式来表示更多的含义：

"kot" in "abc".."xyz" 
>>> true

以上的代码等价于：

"kot" >= "abc" && "kot" <= "xyz" 

中缀表达式

一个中缀函数的表达形式非常简单，我们可以理解成这样：

A 中缀方法 B

如果我们要定义一个中缀函数，它必须需满足以下条件：

• 该中缀函数必须是某个类型的扩展函数或者成员方法；
• 该中缀函数只能有一个参数；
• 中缀函数的参数不能有默认值（虽然Kotlin的函数参数支持默认值），否则以上形式的 B 会缺失，从而对中缀表达式的语义造成破坏；
• 该参数也不能是可变参数，因为我们需要保持参数数量始终为 1 个。

来看看 Kotlin 标准库中采用中缀表达式设计的to方法，这是一个通过泛型实现的方法，可以返回一个Pair。

infix fun <A, B> A.to(that: B): Pair<A, B> 

由于to会返回Pair这种键值对的结构数据，因此我们经常会把它与map结合在一起使用。如以下例子：

mapOf(
	1 to "one",
	2 to "two",
	3 to "three"
)

自定义一个中缀表达式：

class Person {
    infix fun called(name: String) {
        println("My name is $name.")
    }
}

fun main() {
    val p = Person()
    p called "Shaw" // 输出：My name is Shaw. 
} 

也可以按照传统方式调用它：

p.called("Shaw")