自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

一篇帶給你Kotin高階函數(shù)詳解

作者：Android編程
開發(fā) 前端
在Kotlin中，高階函數(shù)是指將一個函數(shù)作為另一個函數(shù)的參數(shù)或者返回值。如果用f(x)、g(x)用來表示兩個函數(shù)，那么高階函數(shù)可以表示為f(g(x))。

[[415932]]

 前言

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

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

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

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

  • 如果一個函數(shù)接收另一個函數(shù)作為參數(shù)，或者返回值的類型是另一個函數(shù)，那么該函數(shù)就稱為高階函數(shù)。
  • 與java不同的是，在Kotlin中增加了一個函數(shù)類型的概念，如果我們將這種函數(shù)添加到一個函數(shù)的參數(shù)聲明或返回值聲明當(dāng)中，那么這就是一個高階函數(shù)了。
  • 函數(shù)類型語法基本規(guī)則：(String,Int) -> Unit添加到某個函數(shù)的參數(shù)聲明
  1. public fun test2(test:Int,block:()->Unit){ 
  2.  
  3. var v= block() 
  4.  
  5. DTLog.i("TestTest","Test1") 
  6.  
  7. } 
  8.  
  9. public fun T.test22(block:()->T):T{ 
  10.  
  11. return block() 
  12.  
  13. } 
  14.  
  15. public fun T.test26(block:T.()->Unit){ 
  16.  
  17. block() 
  18.  
  19. } 
  20.  
  21. public fun T.test23(block:(T)->Unit):T{ 
  22.  
  23. return this 
  24.  
  25. } 
  26.  
  27. public fun 
  28.  
  29. var t=block(this) 
  30.  
  31. return t 
  32.  
  33. } 
  34.  
  35. public fun 
  36.  
  37. return block(this) 
  38.  
  39. } 

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

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

  • 所有函數(shù)類型都有一個圓括號括起來的參數(shù)類型列表以及一個返回類型:(A, B) -> C 表示接受類型分別為 A 與 B 兩個參數(shù)并返回一個 C類型值的函數(shù)類型。參數(shù)類型列表可以為空，如 () -> A ，返回值為空，如(A, B) -> Unit;
  • 函數(shù)類型可以有一個額外的接收者類型，它在表示法中的點之前指定，如類型 A.(B) -> C 表示可以在 A 的接收者對象上，調(diào)用一個以 B 類型作為參數(shù)，并返回一個 C 類型值的函數(shù)。
  • 還有一種比較特殊的函數(shù)類型，掛起函數(shù)，它的表示法中有一個 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)用一個內(nèi)聯(lián)函數(shù)時，它不是去調(diào)用該函數(shù)，而是將該函數(shù)的代碼，整段插入到當(dāng)前位置。這樣做的好處是省去了調(diào)用的過程，加快程序運(yùn)行速度。(函數(shù)的調(diào)用過程，由于有前面所說的參數(shù)入棧等操作，所以總要多占用一些時間)。這樣做的不好處：由于每當(dāng)代碼調(diào)用到內(nèi)聯(lián)函數(shù)，就需要在調(diào)用處直接插入一段該函數(shù)的代碼，所以程序的體積將增大。拿生活現(xiàn)象比喻，就像電視壞了，通過電話找修理工來，你會嫌慢，于是干脆在家里養(yǎng)了一個修理工。這樣當(dāng)然是快了，不過，修理工住在你家可就要占地兒了。內(nèi)聯(lián)函數(shù)并不是必須的，它只是為了提高速度而進(jìn)行的一種修飾。要修飾一個函數(shù)為內(nèi)聯(lián)型

使用如下格式：

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

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

  1. inline int max(int a, int b) 
  2.  
  3. { 
  4.  
  5. return (a>b)? a : b; 
  6.  
  7. } 

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

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

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

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

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

  1. //函數(shù)一開始沒有被聲明為inline: 
  2.  
  3. void foo(); 
  4.  
  5. //然后就有代碼調(diào)用它： 
  6.  
  7. foo(); 
  8.  
  9. //在調(diào)用后才有定義函數(shù)為inline: 
  10.  
  11. inline void foo() 
  12.  
  13. { 
  14.  
  15. ...... 
  16.  
  17. } 

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

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

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

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

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

(3) 內(nèi)聯(lián)函數(shù)體中，不能有循環(huán)語句、if語句或switch語句，否則，函數(shù)定義時即使有inline關(guān)鍵字，編譯器也會把該函數(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)換成了匿名類的實現(xiàn)方式。這就表明，我們每調(diào)用一次 Lambda 表達(dá)式，都會創(chuàng)建一個新的匿名類實例，當(dāng)然也會造成額外的內(nèi)存和性能開銷。為了解決這個問題，Kotlin 提供了內(nèi)聯(lián)函數(shù)的功能，它可以將使用 Lambda 表達(dá)式帶來的運(yùn)行時開銷完全消除，只需要在定義高階函數(shù)時加上 inline 關(guān)鍵字的聲明即可

  1. inline fun test111(num1: Int, num2: Int, block: (Int, Int) -> Int): Int { 
  2.  
  3. val result = block(num1, num2) 
  4.  
  5. return result 
  6.  
  7. } 

4、閉包函數(shù)

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

  1. fun main(args: Array) { 
  2.  
  3. val mm = aaa() 
  4.  
  5. println(mm()) 
  6.  
  7. println(mm()) 
  8.  
  9. println(mm()) 
  10.  
  11. println(mm()) 
  12.  
  13. println(mm()) 
  14.  
  15. val kk = bbb() 
  16.  
  17. println(kk("shadow")) //shadow --- 1 
  18.  
  19. println(kk("shadow")) //shadow --- 2 
  20.  
  21. println(kk("shadow")) //shadow --- 3 
  22.  
  23. println(kk("shadow")) //shadow --- 4 
  24.  
  25. println(kk("shadow")) //shadow --- 5 
  26.  
  27. } 
  28.  
  29. //閉包函數(shù) 就是函數(shù)作為返回參數(shù) 
  30.  
  31. fun aaa(): () -> (Int) { 
  32.  
  33. var current = 10 
  34.  
  35. return fun(): Int { 
  36.  
  37. return current++ 
  38.  
  39. } 
  40.  
  41. } 
  42.  
  43. fun bbb(): (String) -> (String) { 
  44.  
  45. var current = 0; 
  46.  
  47. return fun(str: String): String { 
  48.  
  49. current++; 
  50.  
  51. return "$str --- $current"; 
  52.  
  53. } 
  54.  
  55. } 

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

Kotin高階函數(shù)詳解

在 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

  1. @kotlin.internal.InlineOnly 
  2.  
  3. public inline fun T.apply(block: T.() -> Unit): T { 
  4.  
  5. contract { 
  6.  
  7. callsInPlace(block, InvocationKind.EXACTLY_ONCE) 
  8.  
  9. } 
  10.  
  11. block() 
  12.  
  13. return this 
  14.  
  15. } 
  • 傳遞this作為block函數(shù)參數(shù)(調(diào)用時可以省略)，且apply函數(shù)的返回值是調(diào)用者本身;
  • 執(zhí)行一個 T 類型中的方法，變量等，然后返回自身 T;
  • 注意參數(shù) block: T.()，但凡看到 block: T.() -> 這種代碼塊，意味著在大括號 {} 中可以直接調(diào)用T內(nèi)部的 API 而不需要在加上 T. 這種【實際上調(diào)用為 this. ，this. 通常省略】
  1. val str = "hello" 
  2.  
  3. str.apply { length } //可以省略 str. 
  4.  
  5. str.apply { this.length } //可以這樣 

2、let

  1. @kotlin.internal.InlineOnly 
  2.  
  3. public inline fun 
  4.  
  5. contract { 
  6.  
  7. callsInPlace(block, InvocationKind.EXACTLY_ONCE) 
  8.  
  9. } 
  10.  
  11. return block(this) 
  12.  
  13. } 
  • let 方法是傳遞類型 T 返回另外一個類型 R 形式;
  • 傳遞it作為block函數(shù)參數(shù)，且let函數(shù)的返回值是由block函數(shù)決定;

3、also

  1. @kotlin.internal.InlineOnly 
  2.  
  3. @SinceKotlin("1.1") 
  4.  
  5. public inline fun T.also(block: (T) -> Unit): T { 
  6.  
  7. contract { 
  8.  
  9. callsInPlace(block, InvocationKind.EXACTLY_ONCE) 
  10.  
  11. } 
  12.  
  13. block(this) 
  14.  
  15. return this 
  16.  
  17. } 

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

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

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

  1. val str = "hello" 
  2.  
  3. str.also { str.length } //str.必須加上，否則編譯報錯 
  4.  
  5. str.also { it.length } //或者用 it. 

4、with

  1. @kotlin.internal.InlineOnly 
  2.  
  3. public inline fun 
  4.  
  5. contract { 
  6.  
  7. callsInPlace(block, InvocationKind.EXACTLY_ONCE) 
  8.  
  9. } 
  10.  
  11. return receiver.block() 
  12.  
  13. } 
  • with() 方法接收一個類型為 T 的參數(shù)和一個代碼塊
  • 經(jīng)過處理返回一個 R 類型的結(jié)果
  1. val str = "hello" 
  2.  
  3. val ch = with(str) { 
  4.  
  5. get(0) 
  6.  
  7. } 
  8.  
  9. println(ch) //打印 h 

5、run

  1. @kotlin.internal.InlineOnly 
  2.  
  3. public inline fun run(block: () -> R): R { 
  4.  
  5. contract { 
  6.  
  7. callsInPlace(block, InvocationKind.EXACTLY_ONCE) 
  8.  
  9. } 
  10.  
  11. return block() 
  12.  
  13. } 
  • 要求傳遞的是一個代碼塊，同時返回一個任意類型;
  • 但凡函數(shù)接收的是一個代碼塊時，使用的時候一般都建議使用 {} 來包含代碼塊中的邏輯，只有在一些特殊情況下可以參數(shù) (::fun) 的形式進(jìn)行簡化
  1. @kotlin.internal.InlineOnly 
  2.  
  3. public inline fun 
  4.  
  5. contract { 
  6.  
  7. callsInPlace(block, InvocationKind.EXACTLY_ONCE) 
  8.  
  9. } 
  10.  
  11. return block() 
  12.  
  13. } 
  • 此處是執(zhí)行一個 T 類型的 run 方法，傳遞的依然是一個代碼塊，
  • 只是內(nèi)部執(zhí)行的是 T 的內(nèi)部一個變量 或 方法等，返回的是 一個 R 類型
  1. run { 
  2.  
  3. println(888) 
  4.  
  5. } 
  6.  
  7. val res = run { 2 + 3 } 
  8.  
  9. fun runDemo() { 
  10.  
  11. println("測試run方法") 
  12.  
  13. } 
  14.  
  15. //我們可以這么干 
  16.  
  17. run(::runDemo) 

6、takeIf

  1. public inline fun T.takeIf(predicate: (T) -> Boolean): T? { 
  2.  
  3. contract { 
  4.  
  5. callsInPlace(predicate, InvocationKind.EXACTLY_ONCE) 
  6.  
  7. } 
  8.  
  9. return if (predicate(this)) this else null 
  10.  
  11. } 
  • 根據(jù)傳遞的參數(shù) T 做內(nèi)部判斷，根據(jù)判斷結(jié)果返回 null 或者 T 自身;
  • 傳遞的是【一元謂詞】代碼塊，像極了 C++ 中的一元謂詞：方法只含有一個參數(shù)，并且返回類型是Boolean類型;
  • 源碼中，通過傳遞的一元謂詞代碼塊進(jìn)行判斷，如果是 true 則返回自身，否則返回 null;
  1. val str = "helloWorld" 
  2.  
  3. str.takeIf { str.contains("hello") }?.run(::println) 

7、takeUnless

  1. public inline fun T.takeUnless(predicate: (T) -> Boolean): T? { 
  2.  
  3. contract { 
  4.  
  5. callsInPlace(predicate, InvocationKind.EXACTLY_ONCE) 
  6.  
  7. } 
  8.  
  9. return if (!predicate(this)) this else null 
  10.  
  11. } 

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

8、repeat()

  1. public inline fun repeat(times: Int, action: (Int) -> Unit) { 
  2.  
  3. contract { callsInPlace(action) } 
  4.  
  5. for (index in 0 until times) { 
  6.  
  7. action(index) 
  8.  
  9. } 
  10.  
  11. } 

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

  • 第一個參數(shù)int類型，重復(fù)次數(shù)，
  • 第二個參數(shù),表示要重復(fù)執(zhí)行的對象
  • 該方法每次執(zhí)行的時候都將執(zhí)行的次數(shù)傳遞給要被重復(fù)執(zhí)行的模塊，至于重復(fù)執(zhí)行模塊是否需要該值，需要根據(jù)業(yè)務(wù)實際需求考慮，例如：
  1. public inline fun repeat(times: Int, action: (Int) -> Unit) { 
  2.  
  3. contract { callsInPlace(action) } 
  4.  
  5. for (index in 0 until times) { 
  6.  
  7. action(index) 
  8.  
  9. } 
  10.  
  11. } 

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

 

Kotin高階函數(shù)詳解

 

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

總結(jié)

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

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

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

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

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

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

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

 

責(zé)任編輯：姜華 來源： 今日頭條
Kotin高階函數(shù)函數(shù)
相關(guān)推薦

2021-04-16 07:46:13

Serverless 云開發(fā)FaaS

2021-04-14 14:16:58

HttpHttp協(xié)議網(wǎng)絡(luò)協(xié)議

2022-04-29 14:38:49

class文件結(jié)構(gòu)分析

2023-03-09 07:47:56

BeanFactorSpring框架

2022-03-03 09:05:17

索引MySQL數(shù)據(jù)查詢

2021-03-28 09:12:58

多線程死鎖技術(shù)熱點

2024-04-15 08:17:21

Spring依賴注入循環(huán)依賴

2021-07-12 06:11:14

SkyWalking 儀表板UI篇

2021-07-21 09:48:20

etcd-wal模塊解析數(shù)據(jù)庫

2021-04-08 11:00:56

CountDownLaJava進(jìn)階開發(fā)

2021-06-21 14:36:46

Vite 前端工程化工具

2021-01-28 08:55:48

Elasticsear數(shù)據(jù)庫數(shù)據(jù)存儲

2021-04-01 10:51:55

MySQL鎖機(jī)制數(shù)據(jù)庫

2023-03-29 07:45:58

VS編輯區(qū)編程工具

2021-03-12 09:21:31

MySQL數(shù)據(jù)庫邏輯架構(gòu)

2022-03-22 09:09:17

HookReact前端

2024-06-13 08:34:48

2022-02-17 08:53:38

ElasticSea集群部署

2022-02-25 15:50:05

OpenHarmonToggle組件鴻蒙

2021-04-14 07:55:45

Swift 協(xié)議Protocol
點贊
收藏

51CTO技術(shù)棧公眾號