Kotlin Koans 学习笔记 —— Unit 5

Kotlin Koans 学习笔记 —— Unit 1
Kotlin Koans 学习笔记 —— Unit 2
Kotlin Koans 学习笔记 —— Unit 3
Kotlin Koans 学习笔记 —— Unit 4

36 扩展函数

fun task36(): List<Boolean> {
    fun Int.isEven():Boolean {return this%2 ==0 } //偶数
    val isOdd: Int.() -> Boolean = { this%2==1 }  //奇数

    return listOf(42.isOdd(), 239.isOdd(), 294823098.isEven())
}

Kotlin 的扩展函数非常有趣，声明格式也很简单。
扩展函数与普通函数其实区别不大，只不过函数的作用域是被扩展的类，调用的时候如同使用该类自身的成员方法一样。

37 扩展函数作为参数

fun task37(): Map<Int, String> {
    fun <K, V> buildMap(bulid: HashMap<K, V>.() -> Unit): Map<K, V> {
        val map = hashMapOf<K, V>()
        map.bulid()
        return map

    }
    return buildMap {
        put(0, "0")
        for (i in 1..10) {
            put(i, "$i")
        }
    }
}

创建了一个buildMap(bulid: HashMap<K, V>.() -> Unit) 函数，该函数接收的参数是HashMap的扩展函数，kotlin中函数自身也可以作为参数传入一个函数，扩展函数本质是一个限定作用域的函数，自然也可以作为参数传入。

38 自行实现 apply 扩展函数

fun <T> T.myApply(f: T.() -> Unit): T {
    f()
    return this
}

这一题其实就是上一题的拓展，也是强调扩展函数本身与普通函数差别不大，可以最为参数传入别的函数。

上图可见我们传入的参数本身，其实是一个扩展函数。

39 html构造器

fun renderProductTable(): String {
    return html {
        table {
            tr {
                td {
                    text("Product")
                }
                td {
                    text("Price")
                }
                td {
                    text("Popularity")
                }
            }
            val products = getProducts()
            for ((index,product) in products.withIndex()){
                tr {
                    td(color = getCellColor(index,0)){
                        text(product.description)
                    }
                    td (color = getCellColor(index,1)) {
                        text(product.price)
                    }
                    td (color = getCellColor(index,2)){
                        text(product.popularity)
                    }
                }
            }
        }
    }.toString()
}

熟悉apply()与扩展函数。

40 上一题的构造器是如何工作的

fun task40() = linkedMapOf<Int, Answer>(
/*
1. In the Kotlin code
        tr {
            td {
                text("Product")
            }
            td {
                text("Popularity")
            }
        }
'td' is:
    a. special built-in syntactic construct 特殊的内置语法结构
    b. function declaration 函数声明
    c. function invocation  函数调用
 */
        1 to c,

/*
2. In the Kotlin code
            tr (color = "yellow") {
                td {
                    text("Product")
                }
                td {
                    text("Popularity")
                }
            }
'color' is:
  a. new variable declaration 新的变量声明
  b. argument name  参数名
  c. argument value 参数值
 */
        2 to b,

/*
3. The block
                 {
                     text("Product")
                 }
from the previous question is:
  a. block inside built-in syntax construction 'td' 块内置语法构造'td'
  b. function literal (or "lambda") 函数显式声明
  c. something mysterious 一些神秘的东西

 */
        3 to b,

/*
4. For the code
            tr (color = "yellow") {
                this.td {
                    text("Product")
                }
                td {
                    text("Popularity")
                }
            }
which of the following is true:
  a. this code doesn't compile  这段代码不能编译
  b. 'this' refers to an instance of an outer class this是一个外部类的实例
  c. 'this' refers to a receiver parameter TR of the function literal: 'this'指的是函数显式声明的接收器参数TR
            tr (color = "yellow") {
                  this@tr.td {
                      text("Product")
                  }
            }
 */
        4 to c
)

很简单的一题，命名参数、扩展函数、lambda表达式