Day4 Kotlin 高级特性

解构

Kotlin使用operator 约定解构 operator ：将一个函数标记为重载一个操作符或者实现一个约定固定用法使用 operator 配合 component（固定用法）

kotlin 复制代码

data class Point(val x: Int, val y: Int){ 
    // 对应第一个解构变量 这两个component Point 编译器会自动帮我们实现的
    operator fun component1() = x 
    // 对应第二个解构变量 
    operator fun component2() = y 
}
val (x, y) = Point(1, 2) // 解构
这玩意是不是豁然开朗像不像swift的元祖赋值
// Swift ------ 原生元组，语言直接支持
let point = (x: 1, y: 2) 
let (x, y) = point // 天然就能解构
完美匹配

循环与集合操作符

scss 复制代码

//1..10 闭区间
for (i in 1..10) { println(i) }
for i in 1...10 { print(i) }

//1 until 10 半开区间（不含10）
for (i in 1 until 10) { println(i) }
for i in 1..<10 { print(i) }

//倒序
for (i in 10 downTo 1) { println(i) }
for i in (1...10).reversed() { print(i) }

//步长
for (i in 1..10 step 2) { println(i) }
for i in stride(from: 1, through: 10, by: 2) { print(i) }

//repeat
repeat(10) { println(it) }
for _ in 0..<10 { print("hello") }
// 或者没有原生 repeat，但可以这样
(0..<10).forEach { print($0) }

//遍历数组
// Kotlin
val list = arrayListOf("a", "b", "c", "d")
for (str in list) { println(str) }
// Swift
let list = ["a", "b", "c", "d"]
for str in list { print(str) }

//带下标遍历
// Kotlin
for ((index, str) in list.withIndex()) { 
    println("${index}: $str") 
}
// Swift
for (index, str) in list.enumerated() { 
    print("\(index): \(str)") 
}

运算符

scss 复制代码

filter
// Kotlin
val result = listOf(1,2,3,4,5).filter { it > 3 }
// Swift
let result = [1,2,3,4,5].filter { $0 > 3 }
 `$0` vs `it`，其他完全一样

map
// Kotlin
val result = listOf(1,2,3).map { it * 2 }
// Swift
let result = [1,2,3].map { $0 * 2 }

reduce
// Kotlin
val sum = listOf(1,2,3).reduce { acc, it -> acc + it }
// 或者有初始值用 fold
val sum = listOf(1,2,3).fold(0) { acc, it -> acc + it }
// Swift
let sum = [1,2,3].reduce(0) { $0 + $1 }

flatMap
// Kotlin
val result = listOf(listOf(1,2), listOf(3,4)).flatMap { it }
// Swift
let result = [[1,2],[3,4]].flatMap { $0 }

作⽤域函数

Kotlin 作用域函数，核心就两个问题：怎么引用对象 和 返回什么。

javascript 复制代码

假设你有一个 汉堡对象：
data class Burger(var bread: String = "", var meat: String = "", var sauce: String = "")
val burger = Burger()

`apply` ------ 装配汉堡，返回汉堡
val burger = Burger().apply {
    bread = "全麦"   // 直接写属性，不用 burger.bread
    meat = "牛肉"
    sauce = "番茄酱"
}
// 返回的还是 burger 本身

`also` ------ 检查一眼，返回汉堡
val burger = Burger().apply { ... }
    .also {
        println("做好的汉堡是：$it")  // 看一眼，不改它
    }
// 返回的还是 burger 本身
`let` ------ 拿汉堡做点事，返回结果
val price = burger?.let {
    println("汉堡的面包是：${it.bread}")
    50  // 返回价格，不是汉堡
}
// price = 50
`run` ------ 和 let 一样，但用 this
val price = burger.run {
    println(bread)  // 不用写 it.bread，直接写 bread
    50
}
`with` ------ 和 run 一样，写法不同
val price = with(burger) {
    println(bread)
    50
}

中缀表达式

infix 就是把 a.func(b) 变成 a func b，让代码读起来像一句话。 Swift 没有 infix 函数这个概念，但你可以理解成自定义运算符：

swift 复制代码

// Swift 自定义运算符
infix operator vs
func vs(lhs: Int, rhs: Int) -> String { ... }
5 vs 6  // Swift 也能这样写，但必须是符号
Kotlin
// 创建 Map，正常写法
mapOf(Pair("key", "value"))
// 用 infix 的 to，读起来像自然语言
mapOf("key" to "value")  // key 对应 value，一目了然

DSL

未完待续。。。。。。