[[415708]]

本文轉(zhuǎn)載自微信公眾號「Android開發(fā)編程」，作者Android開發(fā)編程。轉(zhuǎn)載本文請聯(lián)系A(chǔ)ndroid開發(fā)編程公眾號。

前言

在Kotlin中，高階函數(shù)是指將一個(gè)函數(shù)作為另一個(gè)函數(shù)的參數(shù)或者返回值。如果用f(x)、g(x)用來表示兩個(gè)函數(shù)，那么高階函數(shù)可以表示為f(g(x))。Kotlin為開發(fā)者提供了豐富的高階函數(shù)，比如Standard.kt中的let、with、apply等，_Collectioins.kt中的forEach等。為了能夠自如的使用這些高階函數(shù)，我們有必要去了解這些高階函數(shù)的使用方法

今天我們來講解高階函數(shù)

一、高階函數(shù)詳解

1、高階函數(shù)是什么?

• 如果一個(gè)函數(shù)接收另一個(gè)函數(shù)作為參數(shù)，或者返回值的類型是另一個(gè)函數(shù)，那么該函數(shù)就稱為高階函數(shù)。
• 與java不同的是，在Kotlin中增加了一個(gè)函數(shù)類型的概念，如果我們將這種函數(shù)添加到一個(gè)函數(shù)的參數(shù)聲明或返回值聲明當(dāng)中，那么這就是一個(gè)高階函數(shù)了。
• 函數(shù)類型語法基本規(guī)則：(String,Int) -> Unit添加到某個(gè)函數(shù)的參數(shù)聲明

public   fun test2(test:Int,block:()->Unit){ 
     var v=   block() 
        DTLog.i("TestTest","Test1") 
    } 
    public   fun <T>T.test22(block:()->T):T{ 
      return  block() 
    } 
    public   fun <T>T.test26(block:T.()->Unit){ 
        block() 
    } 
    public   fun <T>T.test23(block:(T)->Unit):T{ 
        return this 
    } 
    public  fun <T,R> T.test3(block: (T) -> R):R{ 
        var t=block(this) 
        return t 
    } 
    public  fun <T, W> T.test4(block: (T) -> W): W { 
        return block(this) 
    } 

以上就是一個(gè)高階函數(shù)，它接收了一個(gè)函數(shù)類型的參數(shù)，而調(diào)用高階函數(shù)的方法與調(diào)用普通函數(shù)差異不大，只需要在參數(shù)名后面加上括號，并在括號中傳入必要的參數(shù)即可;

高階函數(shù)類型具有與函數(shù)簽名相對應(yīng)的特殊表示法，即它們的參數(shù)和返回值:

• 所有函數(shù)類型都有一個(gè)圓括號括起來的參數(shù)類型列表以及一個(gè)返回類型:(A, B) -> C 表示接受類型分別為 A 與 B 兩個(gè)參數(shù)并返回一個(gè) C類型值的函數(shù)類型。參數(shù)類型列表可以為空，如 () -> A ，返回值為空，如(A, B) -> Unit;
• 函數(shù)類型可以有一個(gè)額外的接收者類型，它在表示法中的點(diǎn)之前指定，如類型 A.(B) -> C 表示可以在 A 的接收者對象上，調(diào)用一個(gè)以 B 類型作為參數(shù)，并返回一個(gè) C 類型值的函數(shù)。
• 還有一種比較特殊的函數(shù)類型，掛起函數(shù)，它的表示法中有一個(gè) suspend 修飾符 ，例如 suspend () -> Unit 或者 suspend A.(B) -> C 。

2、內(nèi)聯(lián)函數(shù)詳解

①內(nèi)聯(lián)函數(shù)是什么

inline(小心，不是online)，翻譯成“內(nèi)聯(lián)”或“內(nèi)嵌”。意指：當(dāng)編譯器發(fā)現(xiàn)某段代碼在調(diào)用一個(gè)內(nèi)聯(lián)函數(shù)時(shí)，它不是去調(diào)用該函數(shù)，而是將該函數(shù)的代碼，整段插入到當(dāng)前位置。這樣做的好處是省去了調(diào)用的過程，加快程序運(yùn)行速度。(函數(shù)的調(diào)用過程，由于有前面所說的參數(shù)入棧等操作，所以總要多占用一些時(shí)間)。這樣做的不好處：由于每當(dāng)代碼調(diào)用到內(nèi)聯(lián)函數(shù)，就需要在調(diào)用處直接插入一段該函數(shù)的代碼，所以程序的體積將增大。拿生活現(xiàn)象比喻，就像電視壞了，通過電話找修理工來，你會(huì)嫌慢，于是干脆在家里養(yǎng)了一個(gè)修理工。這樣當(dāng)然是快了，不過，修理工住在你家可就要占地兒了。內(nèi)聯(lián)函數(shù)并不是必須的，它只是為了提高速度而進(jìn)行的一種修飾。要修飾一個(gè)函數(shù)為內(nèi)聯(lián)型

使用如下格式：

inline 函數(shù)的聲明或定義

簡單一句話，在函數(shù)聲明或定義前加一個(gè) inline 修飾符。

inline int max(int a, int b)  
{  
   return (a>b)? a : b;  
} 

內(nèi)聯(lián)函數(shù)的本質(zhì)是，節(jié)省時(shí)間但是消耗空間。

②內(nèi)聯(lián)函數(shù)規(guī)則

inline函數(shù)的規(guī)則

(1)、一個(gè)函數(shù)可以自已調(diào)用自已，稱為遞歸調(diào)用(后面講到)，含有遞歸調(diào)用的函數(shù)不能設(shè)置為inline;

(2)、使用了復(fù)雜流程控制語句：循環(huán)語句和switch語句，無法設(shè)置為inline;

(3)、由于inline增加體積的特性，所以建議inline函數(shù)內(nèi)的代碼應(yīng)很短小。最好不超過5行。

(4)、inline僅做為一種“請求”，特定的情況下，編譯器將不理會(huì)inline關(guān)鍵字，而強(qiáng)制讓函數(shù)成為普通函數(shù)。出現(xiàn)這種情況，編譯器會(huì)給出警告消息。

(5)、在你調(diào)用一個(gè)內(nèi)聯(lián)函數(shù)之前，這個(gè)函數(shù)一定要在之前有聲明或已定義為inline,如果在前面聲明為普通函數(shù)，而在調(diào)用代碼后面才定義為一個(gè)inline函數(shù)，程序可以通過編譯，但該函數(shù)沒有實(shí)現(xiàn)inline。比如下面代碼片段：

//函數(shù)一開始沒有被聲明為inline:

void foo();

//然后就有代碼調(diào)用它：

foo();

//在調(diào)用后才有定義函數(shù)為inline:

inline void foo()  
{  
   ......  
}  

代碼是的foo()函數(shù)最終沒有實(shí)現(xiàn)inline;

(6)、為了調(diào)試方便，在程序處于調(diào)試階段時(shí)，所有內(nèi)聯(lián)函數(shù)都不被實(shí)現(xiàn)

③內(nèi)聯(lián)函數(shù)時(shí)應(yīng)注意以下幾個(gè)問題

(1) 在一個(gè)文件中定義的內(nèi)聯(lián)函數(shù)不能在另一個(gè)文件中使用。它們通常放在頭文件中共享。

(2) 內(nèi)聯(lián)函數(shù)應(yīng)該簡潔，只有幾個(gè)語句，如果語句較多，不適合于定義為內(nèi)聯(lián)函數(shù)。

(3) 內(nèi)聯(lián)函數(shù)體中，不能有循環(huán)語句、if語句或switch語句，否則，函數(shù)定義時(shí)即使有inline關(guān)鍵字，編譯器也會(huì)把該函數(shù)作為非內(nèi)聯(lián)函數(shù)處理。

(4) 內(nèi)聯(lián)函數(shù)要在函數(shù)被調(diào)用之前聲明。關(guān)鍵字inline 必須與函數(shù)定義體放在一起才能使函數(shù)成為內(nèi)聯(lián)，僅將inline 放在函數(shù)聲明前面不起任何作用。

3、高階函數(shù)中使用內(nèi)聯(lián)函數(shù)

直使用的 Lambda 表達(dá)式在底層被轉(zhuǎn)換成了匿名類的實(shí)現(xiàn)方式。這就表明，我們每調(diào)用一次 Lambda 表達(dá)式，都會(huì)創(chuàng)建一個(gè)新的匿名類實(shí)例，當(dāng)然也會(huì)造成額外的內(nèi)存和性能開銷。為了解決這個(gè)問題，Kotlin 提供了內(nèi)聯(lián)函數(shù)的功能，它可以將使用 Lambda 表達(dá)式帶來的運(yùn)行時(shí)開銷完全消除，只需要在定義高階函數(shù)時(shí)加上 inline 關(guān)鍵字的聲明即可

inline fun test111(num1: Int, num2: Int, block: (Int, Int) -> Int): Int { 
        val result = block(num1, num2) 
        return result 
    } 

4、閉包函數(shù)

閉包函數(shù) 一個(gè)函數(shù)的返回值是函數(shù)，函數(shù)的內(nèi)部包含另一個(gè)函數(shù)，可以是有參無參的匿名函數(shù)

fun main(args: Array<String>) { 
    val mm = aaa() 
    println(mm()) 
    println(mm()) 
    println(mm()) 
    println(mm()) 
    println(mm()) 
    val  kk = bbb() 
    println(kk("shadow")) //shadow --- 1 
    println(kk("shadow")) //shadow --- 2 
    println(kk("shadow")) //shadow --- 3 
    println(kk("shadow")) //shadow --- 4 
    println(kk("shadow")) //shadow --- 5 
} 
//閉包函數(shù) 就是函數(shù)作為返回參數(shù) 
fun aaa(): () -> (Int) { 
    var current = 10 
    return fun(): Int { 
        return current++ 
    } 
} 
fun bbb(): (String) -> (String) { 
    var current = 0; 
    return fun(str: String): String { 
        current++; 
        return "$str --- $current"; 
    } 
} 

二、kotin中標(biāo)準(zhǔn)庫Standard.kt源碼講解

在 Kotlin 源碼的Standard.kt標(biāo)準(zhǔn)庫中提供了一些便捷的內(nèi)置高階函數(shù)( let、also、with、run、apply )，可以幫助我們寫出更簡潔優(yōu)雅的 Kotlin 代碼，提高開發(fā)效率，學(xué)習(xí)源碼可以更快的幫助我們理解和應(yīng)用

1、apply

@kotlin.internal.InlineOnly 
public inline fun <T> T.apply(block: T.() -> Unit): T { 
    contract { 
        callsInPlace(block, InvocationKind.EXACTLY_ONCE) 
    } 
    block() 
    return this 
} 

• 傳遞this作為block函數(shù)參數(shù)(調(diào)用時(shí)可以省略)，且apply函數(shù)的返回值是調(diào)用者本身;
• 執(zhí)行一個(gè) T 類型中的方法，變量等，然后返回自身 T;
• 注意參數(shù) block: T.()，但凡看到 block: T.() -> 這種代碼塊，意味著在大括號 {} 中可以直接調(diào)用T內(nèi)部的 API 而不需要在加上 T. 這種【實(shí)際上調(diào)用為 this. ，this. 通常省略】

val str = "hello"

str.apply { length } //可以省略 str.

str.apply { this.length } //可以這樣

2、let

@kotlin.internal.InlineOnly 
public inline fun <T, R> T.let(block: (T) -> R): R { 
    contract { 
        callsInPlace(block, InvocationKind.EXACTLY_ONCE) 
    } 
    return block(this) 
} 

• let 方法是傳遞類型 T 返回另外一個(gè)類型 R 形式;
• 傳遞it作為block函數(shù)參數(shù)，且let函數(shù)的返回值是由block函數(shù)決定;

3、also

@kotlin.internal.InlineOnly 
@SinceKotlin("1.1") 
public inline fun <T> T.also(block: (T) -> Unit): T { 
    contract { 
        callsInPlace(block, InvocationKind.EXACTLY_ONCE) 
    } 
    block(this) 
    return this 
} 

執(zhí)行一個(gè) T 類型中的方法，變量等，然后返回自身 T;

傳遞it作為block函數(shù)參數(shù)(調(diào)用時(shí)不可以省略)，且also函數(shù)的返回值是調(diào)用者本身;

這個(gè)方法與上面的 apply 方法類似，只是在大括號中執(zhí)行 T 自身方法的時(shí)候，必須要加上 T. 否則無法調(diào)用 T 中的 API,什么意思呢?看下面代碼：

val str = "hello"

str.also { str.length } //str.必須加上，否則編譯報(bào)錯(cuò)

str.also { it.length } //或者用 it.

4、with

@kotlin.internal.InlineOnly 
public inline fun <T, R> with(receiver: T, block: T.() -> R): R { 
    contract { 
        callsInPlace(block, InvocationKind.EXACTLY_ONCE) 
    } 
    return receiver.block() 
} 

• with() 方法接收一個(gè)類型為 T 的參數(shù)和一個(gè)代碼塊
• 經(jīng)過處理返回一個(gè) R 類型的結(jié)果

val str = "hello" 
val ch = with(str) { 
    get(0) 
} 
println(ch) //打印 h 

5、run

@kotlin.internal.InlineOnly 
public inline fun <R> run(block: () -> R): R { 
    contract { 
        callsInPlace(block, InvocationKind.EXACTLY_ONCE) 
    } 
    return block() 
} 

• 要求傳遞的是一個(gè)代碼塊，同時(shí)返回一個(gè)任意類型;
• 但凡函數(shù)接收的是一個(gè)代碼塊時(shí)，使用的時(shí)候一般都建議使用 {} 來包含代碼塊中的邏輯，只有在一些特殊情況下可以參數(shù) (::fun) 的形式進(jìn)行簡化

@kotlin.internal.InlineOnly 
public inline fun <T, R> T.run(block: T.() -> R): R { 
    contract { 
        callsInPlace(block, InvocationKind.EXACTLY_ONCE) 
    } 
    return block() 
} 

• 此處是執(zhí)行一個(gè) T 類型的 run 方法，傳遞的依然是一個(gè)代碼塊，
• 只是內(nèi)部執(zhí)行的是 T 的內(nèi)部一個(gè)變量 或 方法等，返回的是 一個(gè) R 類型

run { 
    println(888) 
} 
val res = run { 2 + 3 } 
fun runDemo() { 
    println("測試run方法") 
} 
//我們可以這么干 
run(::runDemo) 

6、takeIf

public inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? { 
    contract { 
        callsInPlace(predicate, InvocationKind.EXACTLY_ONCE) 
    } 
    return if (predicate(this)) this else null 
} 

• 根據(jù)傳遞的參數(shù) T 做內(nèi)部判斷，根據(jù)判斷結(jié)果返回 null 或者 T 自身;
• 傳遞的是【一元謂詞】代碼塊，像極了 C++ 中的一元謂詞：方法只含有一個(gè)參數(shù)，并且返回類型是Boolean類型;
• 源碼中，通過傳遞的一元謂詞代碼塊進(jìn)行判斷，如果是 true 則返回自身，否則返回 null;

val str = "helloWorld" 
str.takeIf { str.contains("hello") }?.run(::println) 

7、takeUnless

public inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T? { 
    contract { 
        callsInPlace(predicate, InvocationKind.EXACTLY_ONCE) 
    } 
    return if (!predicate(this)) this else null 
} 

這個(gè)方法跟 takeIf() 方法類似，只是內(nèi)部判斷為false的時(shí)候返回自身T ，而 true 的時(shí)候返回 null，因此不過多說明，使用參考 takeIf() 方法。

8、repeat()

public inline fun repeat(times: Int, action: (Int) -> Unit) { 
    contract { callsInPlace(action) } 
    for (index in 0 until times) { 
        action(index) 
    } 
} 

分析：repeat 方法包含兩個(gè)參數(shù)：

• 第一個(gè)參數(shù)int類型，重復(fù)次數(shù)，
• 第二個(gè)參數(shù),表示要重復(fù)執(zhí)行的對象
• 該方法每次執(zhí)行的時(shí)候都將執(zhí)行的次數(shù)傳遞給要被重復(fù)執(zhí)行的模塊，至于重復(fù)執(zhí)行模塊是否需要該值，需要根據(jù)業(yè)務(wù)實(shí)際需求考慮，例如：

//打印從0 到 100 的值，次數(shù)用到了內(nèi)部的index

repeat(100) { 
    print(it) 
} 
//有比如，單純的打印helloworld 100 次，就沒有用到index值 
repeat(100){ 
    println("helloworld") 
} 

三、高階函數(shù)選擇

• 如果需要返回自身調(diào)用者本身(即return this)，可以選擇 apply also
• 如果需要傳遞this作為參數(shù)，可以選擇 apply run with
• 如果需要傳遞it作為參數(shù)，可以選擇 let also
• 如果返回值需要函數(shù)決定(即return block())，可以選擇 run with let

總結(jié)

不管是 Kotlin 中內(nèi)置的高階函數(shù)，還是我們自定義的，其傳入的代碼塊樣式，無非以下幾種：

1、block: () -> T 和 block: () -> 具體類型

這種在使用 (::fun) 形式簡化時(shí)，要求傳入的方法必須是無參數(shù)的，返回值類型如果是T則可為任意類型，否則返回的類型必須要跟這個(gè)代碼塊返回類型一致

2、block: T.() -> R 和 block: T.() -> 具體類型

這種在使用 (::fun) 形式簡化時(shí)，要求傳入的方法必須包含一個(gè)T類型的參數(shù)，返回值類型如果是R則可為任意類型，否則返回的類型必須要跟這個(gè)代碼塊返回類型一致。例如 with 和 apply 這兩個(gè)方法

3、block: (T) -> R 和 block: (T) -> 具體類型

這種在使用 (::fun) 形式簡化時(shí)，要求傳入的方法必須包含一個(gè)T類型的參數(shù)，返回值類型如果是R則可為任意類型，否則返回的類型必須要跟這個(gè)代碼塊返回類型一致。例如 let 和 takeIf 這兩個(gè)方法